adopt the Bun Maska README and remove docs/PARITY.md

Author: ipfizz

README.md

@@ -1,121 +1,120 @@
-# Sambar
+# Bun Maska
 
-> Electron's leaner, meaner, much-less-bundled cousin. Built on [Bun](https://bun.sh) and your operating system's own WebKit, because shipping Chromium with every app is how we ended up with 14 GB of RAM disappearing into a chat window.
+> Dip your Electron in some fresh Bun Maska. Built on Bun and your operating system's own WebKit, because shipping 150 MB of Chromium with every desktop app is one of those ideas that made sense in 2013 and has been quietly ruining lives ever since.
 
 ## What
 
-A **drop-in replacement for Electron** that does not bundle 100 MB of Chromium with every desktop app you build.
+A **drop-in replacement for Electron** that refuses to bundle an entire browser engine just so you can put a web page in a native window.
 
-Same `app`, `BrowserWindow`, `ipcMain`, `ipcRenderer` API you already know. Different runtime (Bun, not Node). Different renderer (system WebKit, not Chromium). Same vibe. Smaller fan noise.
+You keep writing against the APIs you already know (`app`, `BrowserWindow`, `ipcMain`, `ipcRenderer`, `Menu`, `dialog`, `clipboard`, `webContents.printToPDF`, `capturePage`, etc.). We swap the heavy parts: runtime becomes Bun instead of Node, renderer becomes whatever WebKit your operating system already ships (WKWebView on macOS, WebKitGTK 6 on Linux). The result is dramatically smaller apps, zero compiled native code in your dependency tree, and a native module system that is just TypeScript calling `dlopen`.
 
-## Why
+## The part worth paying attention to
 
-Because your laptop fan deserves a break, and your users deserve apps under 25 MB.
+Most "lighter Electron" projects are just better at gzipping. Bun Maska does something structurally different.
+
+**A native module is a `.ts` file.**
+
+Need to talk to a serial port, USB device, system keychain, IOKit, a custom sensor, or anything else the OS exposes? In Electron this usually means `node-gyp`, N-API, `electron-rebuild`, and hoping the prebuilts match your exact Electron version forever. In Bun Maska you write a small TypeScript file that `dlopen`s `libSystem`, `libc`, or `IOKit` and calls it directly. No compiler. No build step. No ABI compatibility matrix. No Python summoning ritual when you upgrade.
+
+This is not a roadmap item. It is how Bun Maska itself is built — thirty-plus system libraries wired with **zero** `cc` calls anywhere in the tree.
+
+Add the fact that we ship **no browser engine at all**, and your updates stop being hostage situations, your users stop getting Chromium CVEs that have nothing to do with your code, and your laptop fan gets a long-overdue vacation.
+
+That combination — buildless native extensibility + no engine tax — is the thing no amount of tree-shaking inside a bundled Chromium can ever give you.
+
+## Why (the non-marketing reasons)
+
+Your laptop fan has strong opinions about RAM. Your users have data caps and limited patience. And we are allergic to lying in README files.
+
+Honest measured numbers: a packaged Bun Maska app is roughly a **16–23 MB download** and lands at about **61 MB on disk** once Bun unpacks itself. The equivalent minimal Electron app starts north of 150 MB and only grows from there. Updates are tiny because there is no 150 MB engine to re-download. Your OS already patches WebKit. We do not make you participate in the Chromium CVE re-shipping treadmill.
 
 ## Status
 
-**Alpha. Held together with optimism, `strict: true`, and ~980 passing tests.**
+**Alpha.** Held together with optimism, `strict: true`, and 1,380 tests that were green the last time CI ran.
+
+It works properly on both **macOS** and **Linux** today. You get real native windows, system WebKit rendering, full Electron-style IPC with context isolation, application and context menus, tray icons, dialogs, clipboard (text + HTML + images), `nativeImage`, `safeStorage`, `powerMonitor`, `printToPDF`, `capturePage`, and a growing list of other modules — all implemented with pure `bun:ffi` and zero compiled code in the framework.
+
+There is also a CLI that scaffolds projects, runs them with hot reload, and packages real distributables (`.app`/`.dmg` on macOS, AppDir + `.deb` on Linux) with optional auto-update support.
+
+If you are already running this in production, we admire your courage and decline all responsibility. If you are a large company doing an evaluation, please read the word "alpha" three more times before proceeding. If it is still 2027 and this file still opens with the word "alpha", feel free to open an issue titled "are you OK".
 
-It genuinely works on **both macOS and Linux**: native windows, pages rendered by
-your system's own WebKit (WKWebView / WebKitGTK 6), Electron-style IPC end to end,
-application + context menus, tray icons, dialogs, clipboard, `nativeImage`,
-`safeStorage`, `powerMonitor`, and more — all on [Bun](https://bun.sh) via FFI, with
-**zero compiled native code and zero runtime dependencies**. There is also a CLI
-that runs your app and packages it into real distributables (`.app`/`.dmg` on
-macOS, AppDir/`.deb` on Linux).
+## The honest trade-offs
 
-If you are using this in production, we admire your courage and decline all responsibility. If you are a billion-dollar company evaluating this for your next desktop app, talk to us — but read the word "alpha" again first. If you are reading this in 2027 and we still say "alpha," please file an issue titled "are you OK."
+We are not going to sell you a fantasy.
+
+- **Single process.** No Chromium sandbox. No per-window crash isolation. A nasty WebKit or JavaScriptCore crash takes the whole app with it. This is the architectural price of the lightness.
+- **No Windows support yet.** We are waiting for a usable WebKit port on Windows that does not involve shipping Chromium. We are aware this is a hill. We are comfortable dying on it.
+- **~70–80% weighted API parity** for the things most real apps actually use. The long tail (`BrowserView`, sync IPC, Web Serial/WebHID/WebUSB from the renderer, deeply Chromium-internal surfaces) is either out of scope by design or will throw a clear error so you know immediately what is missing.
 
 ## Platforms
 
-| OS | Status |
-|---|---|
-| macOS | actively developed — AppKit + WKWebView via `objc_msgSend` |
-| Linux | actively developed — GTK 4 + WebKitGTK 6 + GIO/GDBus + libsecret via `dlopen` |
-| Windows | deferred until WebKit on Windows is a thing humans can actually use. **We will not ship Chromium.** Yes, we are aware this is a hill. Yes, we are willing to die on it. |
+| OS      | Status                                                                 |
+|---------|------------------------------------------------------------------------|
+| macOS   | Actively developed — AppKit + WKWebView via `objc_msgSend` and hand-built ObjC blocks |
+| Linux   | Actively developed — GTK 4 + WebKitGTK 6 via `dlopen`                  |
+| Windows | Deferred. We will not ship Chromium.                                   |
 
 ## Install
 
-Not on npm yet (it really is alpha). For now, use it from a clone:
+Not on npm yet (it really is alpha). For now:
 
 ```sh
-git clone https://github.com/indrajeetor/sambar.git
-cd sambar && bun install
+git clone https://github.com/indrajeetor/bunmaska.git
+cd bunmaska && bun install
 ```
 
-You will need [Bun](https://bun.sh) ≥ 1.3. Yes, that is the point.
-
-## Hello world
+You need [Bun](https://bun.sh) ≥ 1.3. Yes, that is the entire point.
 
-It opens a real window now. We are as surprised as you are.
+## Quick start
 
 ```ts
-import { app, BrowserWindow } from 'sambar';
+import { app, BrowserWindow } from 'bunmaska';
 
 app.whenReady().then(() => {
-  const win = new BrowserWindow({ width: 960, height: 720, title: 'Hello Sambar' });
+  const win = new BrowserWindow({
+    width: 1024,
+    height: 768,
+    title: 'Hello Bun Maska'
+  });
   win.loadURL('https://example.com');
 });
 ```
 
-Run it with `bun run main.ts` (or `sambar run main.ts` — see below). A native
-window appears, rendered by your operating system's own WebKit — no 100 MB of
-Chromium in sight.
-
-### IPC, the way you remember it
-
-```ts
-// main process
-import { ipcMain } from 'sambar';
-ipcMain.handle('add', (_event, a, b) => a + b);
-```
-
-```ts
-// preload
-import { contextBridge, ipcRenderer } from 'sambar/renderer';
-contextBridge.exposeInMainWorld('api', {
-  add: (a, b) => ipcRenderer.invoke('add', a, b),
-});
-```
-
-`window.api.add(20, 22)` resolves to `42`, round-tripped through real WebKit — in a
-dedicated isolated world, the way `contextIsolation: true` works in Electron.
-
-## Shipping an app
+Run it with `bun run main.ts` (or `bunmaska run main.ts` once you have the CLI).
 
-Sambar ships a CLI (`sambar`) that runs and packages your app — pure Bun, no Xcode
-project, no `electron-builder`:
+## The CLI
 
 ```sh
-sambar run main.ts          # run your app
-sambar build                # produce distributables for the current OS
+bunmaska init my-app     # scaffold a full starter (main + preload + renderer + config)
+bunmaska dev             # run with file watching and auto-restart
+bunmaska run main.ts     # just run it
+bunmaska build           # produce distributables for the current OS
+bunmaska build --update  # also emit the auto-update feed (update.json + .tar.zst)
 ```
 
-`sambar build` compiles your app with `bun build --compile`, bundles it next to the
-Bun runtime (it `dlopen`s system WebKit, so there is no Chromium to ship), and emits:
-
-- **macOS** — a `.app` bundle (with a `.icns` converted from your PNG), optional
-  code-signing/notarization, and a `.dmg`.
-- **Linux** — an AppDir `.tar.gz` and a `.deb`.
-
 ## Migrating from Electron
 
-Point your existing Electron imports at Sambar's drop-in shim:
+Change your imports:
 
 ```ts
-import { app, BrowserWindow } from 'sambar/electron';
+// Before
+import { app, BrowserWindow, ipcMain } from 'electron';
+
+// After
+import { app, BrowserWindow, ipcMain } from 'bunmaska';
+// or use the explicit shim that throws helpful errors on unimplemented modules:
+import { app, BrowserWindow } from 'bunmaska/electron';
 ```
 
-Implemented modules behave like Electron's; anything not yet implemented throws an
-actionable error naming the module (rather than failing silently), so you find the
-gaps immediately. Sambar covers the architectural core (windows, web contents, IPC,
-context isolation, menus, dialog, clipboard, tray, protocol, power, safeStorage,
-nativeImage) on both platforms; see [docs/PARITY.md](./docs/PARITY.md) for the
-module-by-module status and what is still pending.
+Most core modules behave the same. Anything not yet implemented throws an actionable error naming the exact missing module instead of failing mysteriously at 2 a.m.
+
+One migration detail worth knowing up front: Web Serial, WebHID, and WebUSB are Chromium-only. System WebKit does not expose them. If your app uses them from the renderer, that code needs to move to the main process and cross IPC (which, conveniently, is exactly where Bun Maska makes talking to hardware via FFI much more pleasant than the old `node-gyp` dance).
 
 ## Contributing
 
-If you have somehow found this repo before we invited anyone — hi. Open an issue, lower your expectations, and try not to be a jerk. The full contributing guide will appear once we have a working build to contribute to.
+You somehow found this repo before we told anyone. Hello.
+
+Open an issue. Keep your expectations realistic. Try not to be a jerk. A proper contributing guide will exist once the project is less "held together with optimism."
 
 ## License