Sentinel-IR on Android: Install It in Termux Mobile and Verify the Output, Step by Step

From a fresh Termux terminal to a real, inspectable JavaScript analysis report. No desktop computer, no API key, no AI account required.

What this guide does: installs the published sentinel-ir@0.1.1 package, initializes its bundled WebAssembly parser, analyzes a tiny JavaScript example, checks expected results, and saves a JSON report. It then shows how to analyze one JavaScript file you own and how to share sanitized findings under your own account.

What it does not do: it does not prove that a program is secure, scan an entire repository, analyze TypeScript/JSX reliably, or send source code to an LLM. The 0.1.1 release was tested in Termux. This walkthrough uses the published package's documented API and includes troubleshooting because Android and Termux installations can differ.

⚡ The 20-Second Version

You can run a small JavaScript structural analyzer from an Android phone. Termux gives Android a Linux-style terminal, Node.js runs JavaScript, and Sentinel-IR turns a source string into a compact JSON report with facts such as recognized routes, imports, environment variables, operations, and risk signals.

The point of this tutorial is simple: do not take my word for it. Install the exact published version, run the sample, and inspect the output yourself. If you find a problem, report it from your account, with enough detail for someone else to reproduce it.

Yes, this is the kind of project you can experiment with from bed instead of spending the entire evening scrolling. Your phone is not a magic workstation, and not every idea becomes a product. But it can be enough to run a real, testable experiment.

🗺️ Quick Navigation

Tap any link below to jump directly to that section. At the end of each phase, use Contents to return here or Next to continue without scrolling back to the top.

• The 20-Second Version
• How to read the visual markers
• Before We Start: What You Need
• Phase 0: Open Termux
• Phase 1: Update Termux
• Phase 2: Install Node.js
• Phase 3: Create a test folder
• Phase 4: Install Sentinel-IR
• Phase 5: Check the API
• Phase 6: Initialize WebAssembly
• Phase 7: Create the sample
• Phase 8: Create the analysis script
• Phase 9: Run the analysis
• Phase 10: Verify the findings
• Phase 11: Try your own file (optional)
  • Option A: File inside Termux
  • Option B: File in Android Downloads
• Phase 12: Understand the result
• Phase 13: Share findings safely
• Troubleshooting
  • Repository errors
  • node: command not found
  • Node.js is older than version 20
  • Native build warnings or errors
  • Cannot find module 'sentinel-ir'
  • WebAssembly initialization failed
  • analysisStatus is incomplete
  • Expected route or import is missing
  • npm cannot reach the registry
• What Counts as a Successful Finish?
• One Final Invitation

How to read the visual markers

• 🟦 DO THIS: copy the command block into Termux and press Enter.
• ✅ EXPECTED RESULT: compare your terminal output with this example.
• ⚠️ IF THIS FAILS: stop at that step and use the linked troubleshooting section.
• 🧪 OPTIONAL: skip it on your first run if you only want to verify the package.

Do one step at a time. Continue only when the expected result makes sense. The coloured code syntax and headings are part of DEV.to's normal rendering, not evidence that a test passed.

📦 Before We Start: What You Need

• An Android phone supported by Termux.
• A working internet connection for the initial package downloads.
• A little free storage. Node.js and npm dependencies need room, so do not start with your storage completely full.
• Around 10 to 20 minutes if package downloads behave. Slow mirrors or older installations can take longer.
• No root access, no API key, no OpenAI account, and no desktop computer.

Use the official Termux sources. The maintainers document installation through F-Droid and the official GitHub repository. Avoid random APK files from chat groups or download sites. If you already have Termux installed, do not uninstall it casually: builds from different sources may use different signing keys. Update the installation you already have unless you have a specific reason to switch.

Official project references:

• Sentinel-IR npm package, version 0.1.1
• Sentinel-IR README for tag v0.1.1
• Sentinel-IR source tag v0.1.1
• Official Termux installation instructions

🧭 Phase 0: Open Termux and understand the terminal

Open Termux. You should see a terminal prompt and a blinking cursor. Type or paste a command, then press Enter. Commands in this guide should be run inside Termux unless a step explicitly says otherwise.

A few phone-specific tips:

• Paste one code block at a time. Wait for the prompt to return before pasting the next block.
• If you see a long stream of installation text, that is normal. Read the last few lines if a command fails.
• Do not paste a line that begins with a prompt character such as $. The $ in documentation usually means “type the command after this symbol”. The blocks below omit it.
• If Android closes Termux in the background, reopen it and run the last command again. Do not assume a command completed just because you switched apps.
• You do not need to grant access to all shared phone storage for the first test. We will create everything inside Termux's private home directory.

⬆️ Contents · ➡️ Next: Phase 1

🧭 Phase 1: Update Termux packages

Run:

🟦 DO THIS · Run in Termux

pkg update && pkg upgrade -y

pkg update refreshes the package lists. pkg upgrade -y updates installed packages and automatically accepts the package manager's normal confirmation prompt.

✅ IF IT WORKS: if the command finishes and returns to the prompt, continue.

⚠️ IF THIS FAILS: if it stops with a repository or mirror error, jump to Troubleshooting: repository errors below.

⬆️ Contents · ➡️ Next: Phase 2

🧭 Phase 2: Install Node.js and npm

Sentinel-IR requires Node.js 20 or newer. npm normally comes with the Termux Node.js package.

🟦 DO THIS · Run in Termux

pkg install nodejs -y

Now check both tools:

🟦 DO THIS · Run in Termux

node --version
npm --version

Node should print a version number such as v20.x, v22.x, v24.x, or newer. The exact current version depends on the Termux repository and the day you install it. npm should also print a version number.

Use this extra check to verify the Node major version numerically:

🟦 DO THIS · Run in Termux

node -e "const major = Number(process.versions.node.split('.')[0]); console.log('Node.js:', process.version); if (major < 20) { console.error('Sentinel-IR requires Node.js 20 or newer'); process.exit(1); } console.log('PASS: Node.js version is supported');"

✅ EXPECTED RESULT

PASS: Node.js version is supported

⚠️ IF THIS FAILS: if Node is below 20, do not continue and hope for the best. Update Termux packages and check the available Node package again. See Troubleshooting: old Node.js.

⬆️ Contents · ➡️ Next: Phase 3

🧭 Phase 3: Create a clean test folder

Keep the experiment separate from your photos, downloads, and other projects.

🟦 DO THIS · Run in Termux

mkdir -p "$HOME/sentinel-ir-termux-test"
cd "$HOME/sentinel-ir-termux-test"
pwd

The final command should print a path inside Termux's home directory, usually beginning with /data/data/com.termux/files/home/.

Every file created in the remaining steps will live in this folder. You can return to it later with:

🟦 DO THIS · Run in Termux

cd "$HOME/sentinel-ir-termux-test"

⬆️ Contents · ➡️ Next: Phase 4

🧭 Phase 4: Install the exact published release

First, create a minimal local npm project:

🟦 DO THIS · Run in Termux

npm init -y

Install the exact release covered by this guide, rather than whichever version might be published as latest in the future:

🟦 DO THIS · Run in Termux

npm install --save-exact sentinel-ir@0.1.1

This package has a regular web-tree-sitter dependency and optional native Tree-sitter dependencies. The normal install may try to install those optional native packages too. Our test will explicitly use the bundled WebAssembly parser through analyzeAsync(), which is the intended path when native parser packages are unavailable.

Check that npm installed the exact version:

🟦 DO THIS · Run in Termux

npm ls sentinel-ir

You should see sentinel-ir@0.1.1 in the dependency tree. The package is installed locally in this test folder. You do not need a global npm installation and should not use sudo in Termux.

You can independently ask the public registry which version it serves:

🟦 DO THIS · Run in Termux

npm view sentinel-ir@0.1.1 version

✅ EXPECTED RESULT

0.1.1

⚠️ IF THIS FAILS: if this command says it cannot reach the registry, that is a network or registry access issue, not evidence that the analyzer failed. Check your connection and use the troubleshooting section.

⬆️ Contents · ➡️ Next: Phase 5

🧭 Phase 5: Check that the public API exists

Run this block exactly as shown:

🟦 DO THIS · Run in Termux

node - <<'NODE'
const sentinel = require('sentinel-ir');

for (const name of ['analyzeAsync', 'compress', 'initializeWasm']) {
  console.log(`${name}: ${typeof sentinel[name]}`);
  if (typeof sentinel[name] !== 'function') {
    console.error(`FAIL: missing function ${name}`);
    process.exitCode = 1;
  }
}

if (!process.exitCode) {
  console.log('PASS: expected Sentinel-IR functions are exported');
}
NODE

The three lines should end in function, followed by:

✅ EXPECTED RESULT

PASS: expected Sentinel-IR functions are exported

⚠️ IF THIS FAILS: if you see Cannot find module, check that your terminal is still in the test directory and run npm ls sentinel-ir again. If the installed version is not 0.1.1, return to Phase 4.

⬆️ Contents · ➡️ Next: Phase 6

🧭 Phase 6: Initialize the bundled WebAssembly parser

This is a direct check of the WebAssembly initialization path, before we analyze a file.

🟦 DO THIS · Run in Termux

node - <<'NODE'
const { initializeWasm } = require('sentinel-ir');

initializeWasm()
  .then(() => {
    console.log('PASS: Sentinel-IR WebAssembly parser initialized');
  })
  .catch((error) => {
    console.error('FAIL: WebAssembly initialization failed');
    console.error(error);
    process.exitCode = 1;
  });
NODE

✅ EXPECTED RESULT

PASS: Sentinel-IR WebAssembly parser initialized

⚠️ IF THIS FAILS: if initialization fails, do not quietly move to the next step. See Troubleshooting: WebAssembly initialization. The usual checks are whether the package finished installing, whether the packaged WASM file exists, and whether the exact version is installed.

⬆️ Contents · ➡️ Next: Phase 7

🧭 Phase 7: Create a harmless JavaScript sample

We will analyze text that looks like a tiny Express-style server. Sentinel-IR analyzes the source text; this guide does not run the server. You do not need to install Express because the code is only the input to the parser.

Create the sample:

🟦 DO THIS · Run in Termux

cat > sample.js <<'JS'
const express = require("express");
const fs = require("fs");

const app = express();

app.post("/upload", (req, res) => {
  fs.writeFileSync("/tmp/upload", req.body);
  res.end();
});

app.listen(process.env.PORT);
JS

Check the file was created:

🟦 DO THIS · Run in Termux

cat sample.js

You should see the JavaScript block you just pasted. You can also check its syntax with Node.js without executing the server:

🟦 DO THIS · Run in Termux

node --check sample.js

If the syntax check succeeds, Node normally prints nothing and returns to the prompt. If it reports a syntax error, recreate the file using the full cat block above. Be careful not to include the Markdown code fences in the file.

⬆️ Contents · ➡️ Next: Phase 8

🧭 Phase 8: Create a small analysis program

Now create a reusable script. It reads one JavaScript file, passes the text to analyzeAsync(), compresses the result, and prints JSON. It does not execute the input file, call an LLM, or upload the input.

🟦 DO THIS · Run in Termux

cat > analyze.js <<'JS'
const fs = require('node:fs/promises');
const path = require('node:path');
const { analyzeAsync, compress } = require('sentinel-ir');

async function main() {
  const inputPath = process.argv[2];

  if (!inputPath) {
    console.error('Usage: node analyze.js <file.js>');
    process.exitCode = 1;
    return;
  }

  const source = await fs.readFile(inputPath, 'utf8');
  const ir = await analyzeAsync(source, {
    // Use only the filename in the report, not the full private device path.
    target: path.basename(inputPath),
  });
  const report = compress(ir);

  console.log(JSON.stringify(report, null, 2));

  if (report.analysisStatus !== 'complete') {
    console.error(
      'WARNING: analysisStatus is not complete. Do not treat this result as a complete structural analysis.'
    );
    process.exitCode = 2;
  }
}

main().catch((error) => {
  console.error('ERROR: analysis could not finish.');
  console.error(error && error.stack ? error.stack : error);
  process.exitCode = 1;
});
JS

Check the wrapper's own syntax:

🟦 DO THIS · Run in Termux

node --check analyze.js

Again, a successful syntax check normally prints nothing. This tests the small wrapper, not Sentinel-IR's accuracy.

⬆️ Contents · ➡️ Next: Phase 9

🧭 Phase 9: Run the analysis and save a report

Run:

🟦 DO THIS · Run in Termux

node analyze.js sample.js > report.json
rc=$?
printf 'Analyzer exit code: %s\n' "$rc"

The JSON is saved in report.json, not lost in a wall of terminal output. The exit code means:

• 0: the script produced a result whose analysisStatus is complete.
• 2: a result was produced, but the analysis status was not complete. Read the warning and do not count this as a successful complete analysis.
• 1: the wrapper could not finish, for example because it could not read the input or initialize the parser.

Display the report:

🟦 DO THIS · Run in Termux

cat report.json

The report is JSON. Its exact formatting and some values can vary with the input, but for the supplied valid JavaScript sample you should expect structural facts resembling these:

• analysisStatus should be complete.
• facts.ast should be true.
• facts.routes should include POST /upload.
• facts.imports should include express and fs.
• facts.env should include PORT.
• The report should include recognized operations and risk signals related to the route and file write.

The report's risk estimate is not a verdict that this example is safe or unsafe. The sample deliberately includes an HTTP route and a filesystem write so there is something tangible to inspect.

⬆️ Contents · ➡️ Next: Phase 10

🧭 Phase 10: Verify the findings instead of just looking at a JSON blob

Run an automatic check against the results we expect from the sample:

🟦 DO THIS · Run in Termux

node - <<'NODE'
const report = require('./report.json');
const failures = [];

if (report.analysisStatus !== 'complete') {
  failures.push(`analysisStatus expected complete, got ${report.analysisStatus}`);
}
if (report.facts?.ast !== true) {
  failures.push('facts.ast expected true');
}
if (!Array.isArray(report.facts?.routes) || !report.facts.routes.includes('POST /upload')) {
  failures.push('expected route POST /upload was not found');
}
if (!Array.isArray(report.facts?.imports) || !report.facts.imports.includes('express')) {
  failures.push('expected import express was not found');
}
if (!Array.isArray(report.facts?.imports) || !report.facts.imports.includes('fs')) {
  failures.push('expected import fs was not found');
}
if (!Array.isArray(report.facts?.env) || !report.facts.env.includes('PORT')) {
  failures.push('expected environment variable PORT was not found');
}

if (failures.length) {
  console.error('FAIL: sample analysis did not match expectations');
  for (const failure of failures) console.error(`- ${failure}`);
  process.exitCode = 1;
} else {
  console.log('PASS: the sample produced the expected structural facts');
}
NODE

✅ EXPECTED RESULT

PASS: the sample produced the expected structural facts

This is a reproducible smoke test. It shows that this installed package can parse this particular sample and return the facts checked by the script. It is not a broad benchmark, a full test suite, or proof that every JavaScript pattern is recognized correctly.

You can also print the most useful fields without dumping the whole report:

🟦 DO THIS · Run in Termux

node - <<'NODE'
const r = require('./report.json');
console.log('analysisStatus:', r.analysisStatus);
console.log('routes:', r.facts.routes);
console.log('imports:', r.facts.imports);
console.log('environment variables:', r.facts.env);
console.log('operations:', r.facts.operations);
console.log('risk signals:', r.facts.riskSignals);
NODE

⬆️ Contents · ➡️ Next: Phase 11

🧭 Phase 11: Try a JavaScript File of Your Own · 🧪 OPTIONAL

You have already tested the package with a known sample. Only now try your own input.

Only analyze code you own or are authorized to inspect. Start with one .js file, not an entire repository. Sentinel-IR analyzes one JavaScript file at a time; it does not combine calls or data flow across files.

📁 Option A: The file is already inside Termux

Copy your file into the test directory, or run the analyzer with its path:

🟦 DO THIS · Run in Termux

node analyze.js ./your-file.js > your-file-report.json
rc=$?
printf 'Analyzer exit code: %s\n' "$rc"

Replace your-file.js with the real filename. If you need to keep a report, give it a different name so you do not overwrite report.json.

📱 Option B: The file is in Android Downloads

For this optional path, grant Termux shared-storage access only if you need it:

🟦 DO THIS · Run in Termux

termux-setup-storage

Android may show a permission dialog. Approve it if you want Termux to read your shared files. Then list Downloads:

🟦 DO THIS · Run in Termux

ls "$HOME/storage/downloads"

Copy one JavaScript file into the private test folder, replacing example.js with its exact filename:

🟦 DO THIS · Run in Termux

cp "$HOME/storage/downloads/example.js" "$HOME/sentinel-ir-termux-test/your-file.js"
cd "$HOME/sentinel-ir-termux-test"
node analyze.js your-file.js > your-file-report.json
rc=$?
printf 'Analyzer exit code: %s\n' "$rc"

💡 TIP: if the filename contains spaces, keep the quotation marks. If the file is not listed in Downloads, check the correct folder name with ls. You do not need to enable this permission for the earlier sample test.

A file can be JavaScript-shaped but still use syntax that Sentinel-IR does not support. The package currently targets JavaScript, including CommonJS and ESM. It does not claim general TypeScript, JSX-heavy, or other-language support.

⬆️ Contents · ➡️ Next: Phase 12

🧭 Phase 12: Understand analysisStatus

This field is one of the most important parts of the output.

• complete means AST extraction succeeded and the source parsed without syntax errors. It does not mean every security issue was found.
• incomplete means AST extraction was unavailable or the source did not parse cleanly. The output may rely on text-based fallback heuristics, which can be wrong in either direction.

⚠️ IF THIS FAILS: if a report is incomplete, do not write “Sentinel-IR cleared this file” or “the code is safe”. Instead, report that the result was incomplete and explain which input you used. Depending on the file, check the syntax, make sure it is plain supported JavaScript, and try a smaller reproducible example.

Even complete has strict limits:

1. It is a syntax-based structural report, not full semantic analysis.
2. It examines one file at a time.
3. It may not resolve aliases, computed properties, or behavior passed between modules.
4. It does not prove the application is secure.
5. It reduces some untrusted text passed onward, but it does not eliminate prompt injection.
6. It does not run your app or decide what an AI agent should do.

Do not treat values such as world.confidence as calibrated probabilities. They are configuration or metadata fields, not a validated guarantee that the output is correct.

⬆️ Contents · ➡️ Next: Phase 13

🧭 Phase 13: Share a result without leaking your code

Now for the part that matters if you want to publish a finding.

The JSON report may contain names of imported packages, route paths, environment-variable names, operation names, risk signals, and the target filename you supplied. Those can reveal internal architecture. Even if a secret value is not intentionally extracted, never assume any generated report is automatically safe to publish.

Before posting:

1. Open the report and review every field.
2. Remove or generalize private route names, internal package names, filenames, customer information, and anything that reveals a secret or proprietary design.
3. Do not publish private source code or a report from somebody else's code without permission.
4. Prefer the small synthetic sample from this guide when demonstrating basic behavior.
5. State clearly whether you tested the synthetic sample or your own project.
6. Include the exact version, Node version, command, expected result, actual result, and error text if something failed. Remove access tokens and personal filesystem paths.
7. Do not claim that a single smoke test proves the analyzer is secure or accurate in all cases.

You can check the environment before writing your report:

🟦 DO THIS · Run in Termux

node --version
npm --version
npm ls sentinel-ir

Here is a report template you can adapt for DEV Community, GitLab, a discussion thread, or your own blog:

📝 COPY THIS TEMPLATE AND FILL IT IN

Title: Sentinel-IR 0.1.1 Termux smoke test

Device/OS: [Android version and device, if you want to share]
Termux source: [F-Droid or official GitHub]
Node.js: [output of node --version]
Sentinel-IR: 0.1.1
Input: [synthetic sample / my own authorized JavaScript file]
Command: node analyze.js sample.js
Expected: analysisStatus=complete, route POST /upload, imports express and fs, env PORT
Actual: [what really happened]
Result: [PASS / FAIL / INCOMPLETE]
Notes: [reproducible error or unexpected field, without secrets]

Use your own DEV Community or GitLab account to publish your own test result. You do not need access to the maintainer's account. A useful bug report includes a minimal input that you are allowed to share, the exact version, what you expected, what happened, and whether analysisStatus was complete.

⬆️ Contents · ➡️ Next: Troubleshooting

🧰 Troubleshooting: If Something Goes Wrong

Repository errors when running pkg update

⚠️ IF THIS FAILS: if Termux reports that a repository is unreachable or under maintenance, check your connection and change the Termux mirror:

🟦 DO THIS · Run in Termux

termux-change-repo

Choose an available official mirror in the interface, then run:

🟦 DO THIS · Run in Termux

pkg update && pkg upgrade -y

The Termux maintainers document repository and mirror fixes in their Package Management guide. Do not paste commands from unrelated download sites just because a mirror timed out.

⬆️ Troubleshooting index

node: command not found

Install Node.js again from Termux:

🟦 DO THIS · Run in Termux

pkg update
pkg install nodejs -y
node --version
npm --version

⚠️ IF THIS FAILS: if the package manager itself is broken, resolve the repository issue first.

⬆️ Troubleshooting index

Node.js is older than version 20

Run:

🟦 DO THIS · Run in Termux

pkg update && pkg upgrade -y
pkg install nodejs -y
node --version

⚠️ IF THIS FAILS: if the installed version is still below 20, do not continue with this release. Check the available packages in your Termux repository and follow the official Termux package guidance. Do not install two alternative Node packages blindly; they can conflict.

⬆️ Troubleshooting index

npm install shows native build warnings or errors

Sentinel-IR's native Tree-sitter packages are optional. This guide uses the bundled WASM parser, so retry the installation without optional dependencies:

🟦 DO THIS · Run in Termux

cd "$HOME/sentinel-ir-termux-test"
rm -rf node_modules package-lock.json
npm install --save-exact --omit=optional sentinel-ir@0.1.1

This deliberately skips optional native parser packages. It does not skip the regular web-tree-sitter dependency needed by the WASM path. Then repeat Phase 5 and Phase 6.

Only run the cleanup command in the dedicated test folder created by this guide. Do not run rm -rf node_modules in a project where you need to preserve the current installation.

⬆️ Troubleshooting index

Cannot find module 'sentinel-ir'

Check your location and installation:

🟦 DO THIS · Run in Termux

cd "$HOME/sentinel-ir-termux-test"
npm ls sentinel-ir

⚠️ IF THIS FAILS: if it is missing, install the pinned release again:

🟦 DO THIS · Run in Termux

npm install --save-exact sentinel-ir@0.1.1

⬆️ Troubleshooting index

WebAssembly initialization failed

First verify the package and WASM file are present:

🟦 DO THIS · Run in Termux

cd "$HOME/sentinel-ir-termux-test"
npm ls sentinel-ir web-tree-sitter
ls -lh node_modules/sentinel-ir/wasm/

The published package should include tree-sitter-javascript.wasm. If the folder or file is missing, retry the install in the test directory. Check that the install finished and that the package version is 0.1.1.

⚠️ IF THIS FAILS: if it still fails, keep the complete error message and your Node version. Do not replace the WASM file with an unrelated binary from a random website.

⬆️ Troubleshooting index

analysisStatus is incomplete

The package may have been unable to perform AST extraction, or the file did not parse cleanly. Check:

🟦 DO THIS · Run in Termux

node --check sample.js

Remember that the basic test expects JavaScript. TypeScript, JSX-heavy syntax, or other programming languages are outside the documented support claim. Do not treat fallback results as an equivalent structural parse.

⬆️ Troubleshooting index

The expected route or import is missing

First confirm that you are analyzing the sample from this guide, not another file:

🟦 DO THIS · Run in Termux

cat sample.js
node analyze.js sample.js > report.json

Then inspect report.json. If the sample is exactly as shown, analysisStatus is complete, and the expected fact is still absent, preserve a sanitized copy of the sample and report the mismatch with package version and Node version. That is a useful reproducible issue. Do not change the expected output just to force a pass.

⬆️ Troubleshooting index

npm cannot reach the registry

Check connectivity, then retry:

🟦 DO THIS · Run in Termux

npm ping
npm view sentinel-ir@0.1.1 version

⚠️ IF THIS FAILS: if the registry is temporarily unavailable on your connection, retry later or switch between Wi-Fi and mobile data. Do not post an installation timeout as an analyzer defect until the registry request itself works.

⬆️ Troubleshooting index

✅ What Counts as a Successful Finish?

By the end, all of these should be true:

• node --version is at least 20.
• npm ls sentinel-ir shows version 0.1.1.
• The expected exported functions are present.
• initializeWasm() finishes successfully.
• node analyze.js sample.js writes report.json.
• The report says analysisStatus: "complete" for the sample.
• The verification script prints PASS: the sample produced the expected structural facts.
• You understand that this is a smoke test, not a security certification.

✅ IF ALL CHECKS PASS: you have reproduced a small test of the published package on your phone. That is already useful: you did not need to trust a screenshot or a claim, because you ran the commands and inspected the output yourself.

⚠️ IF THIS FAILS: if a check fails, that is not a personal failure. Keep the error, report the environment, and share only sanitized reproducible details. A failed reproducible test is more useful than a vague statement that something “doesn't work”.

⬆️ Contents · ➡️ Final invitation

🚀 One Final Invitation

Try it with the sample first. Then, if you have a JavaScript file you own and are comfortable inspecting, try that one. Check whether the facts match what the code actually contains. Look for missing facts and false positives. Tell me what you found, including the parts that did not work.

This is a small structural analyzer, not an oracle. The interesting part begins when more people can run the same experiment, compare observations, and challenge the claims with evidence.

Built and released from a phone-friendly workflow. Verified by your own terminal.