nanoshell 1.2.3 → 1.7.2

package/README.md

@@ -14,44 +14,80 @@
 - **Executable Size**: **3.00 MB** Self-Contained Binary
 - **IPC Latency**: **0.00 ms** Zero-Copy Shared Memory Matrix across Python/C++/Rust
 - **CSS Engine**: Universal Dynamic CSS Flex/Grid Gap Engine (0 hardcoded class names)
-- **Display Scaling**: Native 200% High-DPI Monitor Scale Auto-Detection
+# NanoShell (v1.5.0) ⚡
 
----
+> **Created by Suman Biswas**  
+> *Hyper-lightweight 17MB RAM, 120 FPS Native WebKit Desktop Application Framework & Runtime Engine*
 
-## 📦 Quick Start
+NanoShell is an ultra-fast, zero-overhead desktop application engine built with **Zig** and **Ultralight GPU-Accelerated WebKit C++**. It allows web developers to build native desktop applications using HTML, CSS, and Vanilla JavaScript with **17MB RSS RAM footprint**, **120 FPS performance**, and **zero-copy C-level OS bindings**.
 
-### Create App from Template
+---
 
-To scaffold a new native desktop app from template:
+## 🚀 Quick Start
 
 ```bash
+# 1. Scaffold a new application project
 npx nanoshell my-awesome-app
-```
 
-### Run Application
-
-```bash
+# 2. Start Development Mode (In-Window Hot Reloading on Ctrl+S)
 cd my-awesome-app
-npm start
-```
+npx nanoshell start
 
-### Build Production Binary
-
-```bash
+# 3. Build Standalone Production Binary (.exe)
 npx nanoshell build
+
+# 4. Package Windows Installer (.exe + Setup.exe via Inno Setup)
+npx nanoshell package
 ```
 
-Build production release binary only. Generates `dist/my-awesome-app.exe` (3.00 MB, 17.0 MB RAM native executable)!
+---
 
-### Generate Setup Installer (.exe)
+## 📖 Master JavaScript API Reference (`window.NanoShell`)
 
-```bash
-npx nanoshell package
-```
+### 📁 File System (`NanoShell.fs`)
+- `NanoShell.fs.readFile(path)`: Read text file contents.
+- `NanoShell.fs.writeFile(path, content)`: Write text file to disk.
+- `NanoShell.fs.exists(path)`: Check file/directory existence.
+- `NanoShell.fs.readDir(path)`: List directory folder contents.
+- `NanoShell.fs.mkdir(path)`: Create directory folder.
+- `NanoShell.fs.remove(path)`: Delete file or directory.
+
+### 💻 System & OS (`NanoShell.os`)
+- `NanoShell.os.getInfo()`: Get platform, arch (`x64`), core count, and RAM telemetry.
+
+### ⚙️ Shell & Execution (`NanoShell.shell` & `NanoShell.process`)
+- `NanoShell.shell.openExternal(urlOrPath)`: Open URL or file in default OS application.
+- `NanoShell.shell.exec(command)`: Execute CLI command (PowerShell/CMD).
+- `NanoShell.process.list()`: Task Manager process list.
+
+### 🪟 Window & Screen Controls (`NanoShell.window` & `NanoShell.screen`)
+- `NanoShell.window.minimize()`, `maximize()`, `restore()`, `close()`, `center()`, `setTitle()`, `setFullscreen()`.
+- `NanoShell.screen.getMonitors()`: List connected monitors, resolutions, and refresh rates.
+- `NanoShell.screen.getCursorPosition()`: Global mouse desktop coordinates `(x, y)`.
+
+### 📋 Clipboard (`NanoShell.clipboard`)
+- `NanoShell.clipboard.writeText(text)`: Copy text to system clipboard.
+- `NanoShell.clipboard.readText()`: Paste text from system clipboard.
+
+### 💬 OS Dialogs (`NanoShell.dialog`)
+- `NanoShell.dialog.showOpen()`: Native Open File Picker dialog.
+- `NanoShell.dialog.showSave()`: Native Save File Picker dialog.
+- `NanoShell.dialog.showMessage(title, message)`: Native OS Alert message box.
+
+### 🔔 Toast Notifications (`NanoShell.notification`)
+- `NanoShell.notification.show(title, body)`: Trigger native OS Toast notification.
+
+### 🔋 Power & Battery (`NanoShell.power`)
+- `NanoShell.power.getBatteryStatus()`: Battery %, charging status, AC power.
+
+### ⚡ Shared Memory & Snapshot (`NanoShell.shm` & `NanoShell.snapshot`)
+- `NanoShell.shm.createRegion(name, size)`: Zero-copy C RAM allocation (< 0.01ms IPC).
+- `NanoShell.snapshot.thawState()`: < 1ms instant cold-start thaw engine.
+
+---
 
-Build binary and generate Windows installer (`dist/MyApp-Setup.exe` powered by **Inno Setup**)!
-- Provides user choice: **"Install for all users (Admin)"** vs **"Install for me only (Per-User, No Admin)"**
-- High-ratio LZMA2 compression for ultra-compact setup installers
+## 📦 100% Portable Bundle
+Every scaffolded NanoShell app includes portable Visual C++ runtime DLLs (`vcruntime140.dll`, `msvcp140.dll`, `vcruntime140_1.dll`) and is compiled against `x86_64-windows-gnu` baseline CPU targets — ensuring **100% portable out-of-the-box execution on any Windows laptop without admin rights or external installers**.
 - Automatic Start Menu & Desktop shortcuts
 
 

package/cli/bundler.zig

@@ -34,31 +34,73 @@ pub const SingleBinaryBundler = struct {
 
         const cwd = std.Io.Dir.cwd();
 
-        // Copy Main Executable bin/<app_name>.exe -> dist/<app_name>.exe
-        const src_exe_path = try std.fmt.allocPrint(self.allocator, "bin/{s}.exe", .{self.config.app_name});
-        defer self.allocator.free(src_exe_path);
+        // Copy Main Executable (search zig-out/bin, bin, root, example_app.exe)
+        const possible_srcs = [_][]const u8{
+            "zig-out/bin/example_app.exe",
+            "example_app.exe",
+            "bin/example_app.exe",
+            try std.fmt.allocPrint(self.allocator, "bin/{s}.exe", .{self.config.app_name}),
+            try std.fmt.allocPrint(self.allocator, "{s}.exe", .{self.config.app_name}),
+        };
+        const dst_exe_name = try std.fmt.allocPrint(self.allocator, "{s}.exe", .{self.config.app_name});
+        defer self.allocator.free(dst_exe_name);
         const dst_exe_path = try std.fmt.allocPrint(self.allocator, "{s}/{s}.exe", .{ self.config.output_dir, self.config.app_name });
         defer self.allocator.free(dst_exe_path);
 
-        _ = cwd.copyFile(src_exe_path, dist_dir, try std.fmt.allocPrint(self.allocator, "{s}.exe", .{self.config.app_name}), io, .{}) catch |err| {
-            std.log.warn("Executable copy warning: {s}", .{@errorName(err)});
-        };
+        var copied = false;
+        for (possible_srcs) |src| {
+            if (cwd.copyFile(src, dist_dir, dst_exe_name, io, .{})) |_| {
+                copied = true;
+                break;
+            } else |_| {}
+        }
+        if (!copied) {
+            std.log.warn("Executable copy warning: Could not locate baseline executable binary", .{});
+        }
 
-        // Copy DLLs
+        // Copy DLLs to dist/ (search vendor/lib, zig-out/bin, and root)
         const dlls = [_][]const u8{ "AppCore.dll", "Ultralight.dll", "UltralightCore.dll", "WebCore.dll", "vcruntime140.dll", "msvcp140.dll", "vcruntime140_1.dll" };
         for (dlls) |dll| {
-            const src_dll = try std.fmt.allocPrint(self.allocator, "bin/{s}", .{dll});
-            defer self.allocator.free(src_dll);
-            _ = cwd.copyFile(src_dll, dist_dir, dll, io, .{}) catch {};
+            const possible_dll_srcs = [_][]const u8{
+                try std.fmt.allocPrint(self.allocator, "vendor/lib/{s}", .{dll}),
+                try std.fmt.allocPrint(self.allocator, "zig-out/bin/{s}", .{dll}),
+                try std.fmt.allocPrint(self.allocator, "bin/{s}", .{dll}),
+                dll,
+            };
+            defer for (possible_dll_srcs) |p| self.allocator.free(p);
+
+            const dst_dll = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.config.output_dir, dll });
+            defer self.allocator.free(dst_dll);
+
+            for (possible_dll_srcs) |src_dll| {
+                if (copyFileSimple(src_dll, dst_dll)) {
+                    break;
+                }
+            }
         }
 
-        // Copy Resource Files
+        // Copy Resource Files to dist/ and dist/resources/
         const res_files = [_][]const u8{ "icudt67l.dat", "cacert.pem" };
         for (res_files) |file| {
-            const src_res = try std.fmt.allocPrint(self.allocator, "bin/{s}", .{file});
-            defer self.allocator.free(src_res);
-            _ = cwd.copyFile(src_res, dist_dir, file, io, .{}) catch {};
-            _ = cwd.copyFile(src_res, dist_dir, try std.fmt.allocPrint(self.allocator, "resources/{s}", .{file}), io, .{}) catch {};
+            const possible_res_srcs = [_][]const u8{
+                try std.fmt.allocPrint(self.allocator, "vendor/resources/{s}", .{file}),
+                try std.fmt.allocPrint(self.allocator, "resources/{s}", .{file}),
+                try std.fmt.allocPrint(self.allocator, "zig-out/bin/resources/{s}", .{file}),
+                try std.fmt.allocPrint(self.allocator, "bin/{s}", .{file}),
+            };
+            defer for (possible_res_srcs) |p| self.allocator.free(p);
+
+            const dst_res1 = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.config.output_dir, file });
+            defer self.allocator.free(dst_res1);
+            const dst_res2 = try std.fmt.allocPrint(self.allocator, "{s}/resources/{s}", .{ self.config.output_dir, file });
+            defer self.allocator.free(dst_res2);
+
+            for (possible_res_srcs) |src_res| {
+                if (copyFileSimple(src_res, dst_res1)) {
+                    _ = copyFileSimple(src_res, dst_res2);
+                    break;
+                }
+            }
         }
 
         // Copy app/* files to dist/app/*
@@ -78,3 +120,9 @@ pub const SingleBinaryBundler = struct {
         std.log.info("Built Custom Named Executable -> '{s}' (Self-contained release package)", .{dst_exe_path});
     }
 };
+
+fn copyFileSimple(src: []const u8, dst: []const u8) bool {
+    const io = std.Io.Threaded.global_single_threaded.io();
+    std.Io.Dir.cwd().copyFile(src, std.Io.Dir.cwd(), dst, io, .{}) catch return false;
+    return true;
+}

package/cli/dev_server.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const installer = @import("installer.zig");
 
 pub const DevServer = struct {
     allocator: std.mem.Allocator,
@@ -8,14 +9,184 @@ pub const DevServer = struct {
     }
 
     pub fn runDevMode(self: *DevServer, app_dir_name: []const u8) !void {
+        _ = app_dir_name;
         std.log.info("=================================================================", .{});
-        std.log.info("  ⚡ NanoShell Hot-Reload Dev Engine Started for: {s}", .{app_dir_name});
-        std.log.info("  Watching app/ directory for UI changes...", .{});
+        std.log.info("  ⚡ NanoShell Dev Server Started", .{});
+        std.log.info("  Watching app/ directory & nanoshell.json for live changes...", .{});
         std.log.info("=================================================================", .{});
 
-        const exe_path = try std.fmt.allocPrint(self.allocator, "{s}/bin/{s}.exe", .{ app_dir_name, app_dir_name });
-        defer self.allocator.free(exe_path);
+        var config = installer.loadConfig(self.allocator) catch installer.AppConfig{};
+        defer config.deinit(self.allocator);
 
-        std.log.info("Dev Server active for '{s}'. File watcher operational.", .{exe_path});
+        // Find executable inside bin/ or zig-out/bin/
+        const io = std.Io.Threaded.global_single_threaded.io();
+        const cwd = std.Io.Dir.cwd();
+
+        var found_exe: ?[]const u8 = null;
+
+        const candidate_paths = [_][]const u8{
+            "zig-out/bin/example_app.exe",
+            "bin/example_app.exe",
+            "zig-out/bin/nanoshell.exe",
+        };
+
+        for (candidate_paths) |p| {
+            if (cwd.openFile(io, p, .{})) |f| {
+                f.close(io);
+                found_exe = p;
+                break;
+            } else |_| {}
+        }
+
+        if (found_exe == null) {
+            // Search bin/ for any .exe
+            var bin_dir = cwd.openDir(io, "bin", .{ .iterate = true }) catch null;
+            if (bin_dir) |*d| {
+                defer d.close(io);
+                var iter = d.iterate();
+                while (iter.next(io) catch null) |entry| {
+                    if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".exe")) {
+                        found_exe = try std.fmt.allocPrint(self.allocator, "bin/{s}", .{entry.name});
+                        break;
+                    }
+                }
+            }
+        }
+
+        var win_exe_buf: [256]u8 = undefined;
+        const exe_to_run = found_exe orelse "bin\\app.exe";
+        var pos: usize = 0;
+        for (exe_to_run) |ch| {
+            if (ch == '/') {
+                win_exe_buf[pos] = '\\';
+            } else {
+                win_exe_buf[pos] = ch;
+            }
+            pos += 1;
+        }
+        win_exe_buf[pos] = 0;
+        const win_path = win_exe_buf[0..pos];
+
+        var dev_cmd_buf: [300]u8 = undefined;
+        const dev_cmd = std.fmt.bufPrintZ(&dev_cmd_buf, "{s} --dev", .{win_path}) catch win_path;
+
+        std.log.info("Launching NanoShell runtime in DEV mode: {s}", .{dev_cmd});
+
+        // Launch app process once - native engine handles smooth in-window hot reload in dev mode
+        var child = try self.spawnChildProcess(dev_cmd);
+        defer _ = child.kill();
+
+        std.log.info("App running! In-window hot reload active for app/index.html, styles.css, app.js.", .{});
+
+        const WinApi = struct {
+            pub extern "kernel32" fn Sleep(dwMilliseconds: u32) callconv(.winapi) void;
+            pub extern "kernel32" fn GetExitCodeProcess(hProcess: std.os.windows.HANDLE, lpExitCode: *u32) callconv(.winapi) i32;
+        };
+
+        var exit_code: u32 = 259; // STILL_ACTIVE
+        while (exit_code == 259) {
+            WinApi.Sleep(500);
+            _ = WinApi.GetExitCodeProcess(child.hProcess, &exit_code);
+        }
+    }
+
+    fn spawnChildProcess(self: *DevServer, exe_path: []const u8) !ChildProcess {
+        _ = self;
+        var cmd_utf16: [1024]u16 = undefined;
+        const len = try std.unicode.utf8ToUtf16Le(&cmd_utf16, exe_path);
+        cmd_utf16[len] = 0;
+
+        const STARTUPINFOW = extern struct {
+            cb: u32 = 104,
+            lpReserved: ?[*:0]u16 = null,
+            lpDesktop: ?[*:0]u16 = null,
+            lpTitle: ?[*:0]u16 = null,
+            dwX: u32 = 0,
+            dwY: u32 = 0,
+            dwXSize: u32 = 0,
+            dwYSize: u32 = 0,
+            dwXCountChars: u32 = 0,
+            dwYCountChars: u32 = 0,
+            dwFillAttribute: u32 = 0,
+            dwFlags: u32 = 0,
+            wShowWindow: u16 = 0,
+            cbReserved2: u16 = 0,
+            lpReserved2: ?*u8 = null,
+            hStdInput: ?std.os.windows.HANDLE = null,
+            hStdOutput: ?std.os.windows.HANDLE = null,
+            hStdError: ?std.os.windows.HANDLE = null,
+        };
+
+        const PROCESS_INFORMATION = extern struct {
+            hProcess: std.os.windows.HANDLE,
+            hThread: std.os.windows.HANDLE,
+            dwProcessId: u32,
+            dwThreadId: u32,
+        };
+
+        const WinApi = struct {
+            pub extern "kernel32" fn CreateProcessW(
+                lpApplicationName: ?[*:0]const u16,
+                lpCommandLine: ?[*:0]u16,
+                lpProcessAttributes: ?*anyopaque,
+                lpThreadAttributes: ?*anyopaque,
+                bInheritHandles: i32,
+                dwCreationFlags: u32,
+                lpEnvironment: ?*anyopaque,
+                lpCurrentDirectory: ?[*:0]const u16,
+                lpStartupInfo: *const STARTUPINFOW,
+                lpProcessInformation: *PROCESS_INFORMATION,
+            ) callconv(.winapi) i32;
+
+            pub extern "kernel32" fn TerminateProcess(hProcess: std.os.windows.HANDLE, uExitCode: u32) callconv(.winapi) i32;
+            pub extern "kernel32" fn CloseHandle(hObject: std.os.windows.HANDLE) callconv(.winapi) i32;
+        };
+
+        var si = STARTUPINFOW{};
+        var pi: PROCESS_INFORMATION = undefined;
+
+        const res = WinApi.CreateProcessW(null, @ptrCast(&cmd_utf16), null, null, 0, 0, null, null, &si, &pi);
+        if (res == 0) return error.ProcessCreationFailed;
+
+        return ChildProcess{
+            .hProcess = pi.hProcess,
+            .hThread = pi.hThread,
+        };
+    }
+
+    fn getAppModTime(self: *DevServer) i128 {
+        _ = self;
+        const io = std.Io.Threaded.global_single_threaded.io();
+        const cwd = std.Io.Dir.cwd();
+        var max_mtime: i128 = 0;
+
+        var app_dir = cwd.openDir(io, "app", .{ .iterate = true }) catch return 0;
+        defer app_dir.close(io);
+
+        var iter = app_dir.iterate();
+        while (iter.next(io) catch null) |entry| {
+            if (entry.kind == .file) {
+                if (app_dir.statFile(io, entry.name, .{})) |st| {
+                    const ns = st.mtime.toNanoseconds();
+                    if (ns > max_mtime) max_mtime = ns;
+                } else |_| {}
+            }
+        }
+        return max_mtime;
+    }
+};
+
+pub const ChildProcess = struct {
+    hProcess: std.os.windows.HANDLE,
+    hThread: std.os.windows.HANDLE,
+
+    pub fn kill(self: *ChildProcess) void {
+        const WinApi = struct {
+            pub extern "kernel32" fn TerminateProcess(hProcess: std.os.windows.HANDLE, uExitCode: u32) callconv(.winapi) i32;
+            pub extern "kernel32" fn CloseHandle(hObject: std.os.windows.HANDLE) callconv(.winapi) i32;
+        };
+        _ = WinApi.TerminateProcess(self.hProcess, 1);
+        _ = WinApi.CloseHandle(self.hProcess);
+        _ = WinApi.CloseHandle(self.hThread);
     }
 };

package/cli/installer.zig

@@ -185,25 +185,35 @@ pub fn generateIss(allocator: std.mem.Allocator, config: AppConfig) ![]const u8
         \\Name: "desktopicon"; Description: "{{cm:CreateDesktopIcon}}"; GroupDescription: "{{cm:AdditionalIcons}}"; Flags: unchecked
         \\
         \\[Files]
-        \\; Main executable
-        \\Source: "bin\{{#AppExeName}}"; DestDir: "{{app}}"; Flags: ignoreversion
+        \\; Main executable (searches dist, root, zig-out\bin, and bin)
+        \\Source: "dist\{{#AppName}}.exe";          DestDir: "{{app}}"; DestName: "{{#AppExeName}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "example_app.exe";                 DestDir: "{{app}}"; DestName: "{{#AppExeName}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "zig-out\bin\example_app.exe";     DestDir: "{{app}}"; DestName: "{{#AppExeName}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\{{#AppExeName}}";            DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
         \\
-        \\; NanoShell Runtime DLLs & Portable C++ Runtimes
-        \\Source: "bin\AppCore.dll";        DestDir: "{{app}}"; Flags: ignoreversion
-        \\Source: "bin\Ultralight.dll";     DestDir: "{{app}}"; Flags: ignoreversion
-        \\Source: "bin\UltralightCore.dll"; DestDir: "{{app}}"; Flags: ignoreversion
-        \\Source: "bin\WebCore.dll";        DestDir: "{{app}}"; Flags: ignoreversion
-        \\Source: "bin\vcruntime140.dll";   DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
-        \\Source: "bin\msvcp140.dll";       DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
-        \\Source: "bin\vcruntime140_1.dll"; DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\; NanoShell Runtime DLLs & Portable C++ Runtimes (vendor\lib and bin)
+        \\Source: "vendor\lib\AppCore.dll";         DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "vendor\lib\Ultralight.dll";      DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "vendor\lib\UltralightCore.dll";  DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "vendor\lib\WebCore.dll";         DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "vendor\lib\icudt67l.dat";        DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "vendor\lib\cacert.pem";          DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "vendor\lib\resources\*";         DestDir: "{{app}}\resources"; Flags: ignoreversion recursesubdirs createallsubdirs skipifsourcedoesntexist
         \\
-        \\; ICU Unicode data and TLS certs
-        \\Source: "bin\icudt67l.dat"; DestDir: "{{app}}"; Flags: ignoreversion
-        \\Source: "bin\cacert.pem";   DestDir: "{{app}}"; Flags: ignoreversion
-        \\Source: "bin\resources\*";  DestDir: "{{app}}\resources"; Flags: ignoreversion recursesubdirs createallsubdirs
+        \\Source: "bin\AppCore.dll";                DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\Ultralight.dll";             DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\UltralightCore.dll";         DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\WebCore.dll";                DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\vcruntime140.dll";           DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\msvcp140.dll";               DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\vcruntime140_1.dll";         DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\icudt67l.dat";               DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\cacert.pem";                 DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\resources\*";                DestDir: "{{app}}\resources"; Flags: ignoreversion recursesubdirs createallsubdirs skipifsourcedoesntexist
         \\
         \\; App HTML / CSS / JS assets
-        \\Source: "app\*"; DestDir: "{{app}}\app"; Flags: ignoreversion recursesubdirs createallsubdirs
+        \\Source: "example_app\*";                  DestDir: "{{app}}\app"; Flags: ignoreversion recursesubdirs createallsubdirs skipifsourcedoesntexist
+        \\Source: "app\*";                          DestDir: "{{app}}\app"; Flags: ignoreversion recursesubdirs createallsubdirs skipifsourcedoesntexist
         \\
         \\[Icons]
         \\Name: "{{group}}\\{{#AppName}}";                         Filename: "{{app}}\\{{#AppExeName}}"; WorkingDir: "{{app}}"

package/cli/main.zig

@@ -129,12 +129,12 @@ pub fn main() !void {
             \\</head>
             \\<body>
             \\  <div class="container">
-            \\    <div class="fps-badge"><span id="fps-val">60</span> FPS Realtime</div>
+            \\    <div class="fps-badge"><span id="fps-val">120</span> FPS Locked</div>
             \\    <h1>⚡ NanoShell Desktop App</h1>
             \\    <p>Ultra-lightweight WebKit desktop runtime</p>
             \\    <button id="btn">Click Me</button>
             \\  </div>
-            \\  <script src="app.js"></script>
+            \\  <!-- app.js is injected inline by the NanoShell engine at load time -->
             \\</body>
             \\</html>
         ;
@@ -184,26 +184,15 @@ pub fn main() !void {
         try app_dir.writeFile(io, .{ .sub_path = "app/styles.css", .data = css_content });
 
         const js_content =
-            \\let lastTime = performance.now();
-            \\let frames = 0;
-            \\function calcFps() {
-            \\  const now = performance.now();
-            \\  frames++;
-            \\  const delta = now - lastTime;
-            \\  if (delta >= 500) {
-            \\    const fps = Math.round((frames * 1000) / delta);
-            \\    const el = document.getElementById('fps-val');
-            \\    if (el) el.innerText = fps;
-            \\    frames = 0;
-            \\    lastTime = now;
-            \\  }
-            \\  requestAnimationFrame(calcFps);
-            \\}
-            \\requestAnimationFrame(calcFps);
+            \\// NanoShell Application JavaScript (0% Idle CPU Overhead)
+            \\console.log('⚡ [NanoShell] App loaded successfully');
             \\
-            \\document.getElementById('btn').addEventListener('click', () => {
-            \\  alert('Hello from NanoShell!');
-            \\});
+            \\const btn = document.getElementById('btn');
+            \\if (btn) {
+            \\  btn.addEventListener('click', () => {
+            \\    alert('Hello from NanoShell!');
+            \\  });
+            \\}
         ;
         try app_dir.writeFile(io, .{ .sub_path = "app/app.js", .data = js_content });