@omega.js/desktop 0.1.0

package/docs/tray.md

@@ -0,0 +1,164 @@
+# Tray
+
+File-based tray/menubar. @omega.js/desktop looks for `src/integrations/tray/index.js`; if it exists, the exported function is called during boot with a builder API + id-path API. If absent, @omega.js/desktop ships a default tray template (see ids below).
+
+## Config
+
+No config block. Path is conventional: `src/integrations/tray/index.js`. To opt out, call `manager.tray.disable()` from your main entry — idempotent, tears down any existing Tray.
+
+## Definition file
+
+```js
+// src/integrations/tray/index.js
+module.exports = ({ manager, tray }) => {
+  // @omega.js/desktop auto-resolves the tray icon from config/icons/<platform>/tray.png at build
+  // time, so explicit tray.icon() is OPTIONAL. Call it only to override.
+  // Note: on macOS, if you pass your own path, the filename MUST end in
+  // `Template.png` for the OS to auto-invert it in dark mode.
+  // tray.icon('src/assets/icons/my-trayTemplate.png');
+  tray.tooltip(manager.config?.app?.productName);
+
+  // Easiest: start from @omega.js/desktop's default template.
+  tray.useDefaults();
+
+  // Then customize by id (flat — no `tray/` prefix needed):
+  tray.insertAfter('open', {
+    id: 'dashboard',
+    label: 'Open Dashboard',
+    click: () => manager.windows.show('dashboard'),
+  });
+  tray.update('open', { label: 'Show Window' });
+  tray.remove('website');
+  tray.hide('check-for-updates');
+};
+```
+
+## Builder API (during definition)
+
+```js
+tray.icon(path)                // sets the tray icon (relative paths resolved from cwd)
+tray.tooltip(text)
+tray.item(descriptor)          // see "Item descriptors" below
+tray.separator()
+tray.submenu(label, items)
+tray.useDefaults()             // populate with @omega.js/desktop's default template (id-tagged)
+tray.clear()                   // start over
+```
+
+## Id-path API
+
+Same shape across menu / tray / context-menu. Available **during definition** (on the `tray` builder arg) AND **at runtime** on `manager.tray`:
+
+```js
+.find(idPath)                  // live descriptor or null
+.has(idPath)                   // bool
+.update(idPath, patch)         // Object.assign + re-render. returns true if found.
+.remove(idPath)                // splice + re-render. returns true if removed.
+.enable(idPath, bool = true)   // sugar over update({enabled})
+.show(idPath, bool = true)     // sugar over update({visible})
+.hide(idPath)                  // visible:false
+.insertBefore(idPath, item)    // splice in a sibling
+.insertAfter(idPath, item)     // splice in a sibling
+.appendTo(idPath, item)        // push into a submenu (creates submenu if absent)
+```
+
+Tray ids are **flat** — no `tray/` prefix (the lib namespace is implicit). For nested submenus you can address children by `parent/child` paths (the resolver walks `submenu` arrays).
+
+## Default template ids
+
+| ID | Item |
+|---|---|
+| `title` | Disabled label showing the app name |
+| `open` | "Open `<app>`" — calls `manager.windows.show('main')` |
+| `check-for-updates` | Wired to `manager.autoUpdater` (label updates dynamically) |
+| `website` | Visit `brand.url` (only present if configured) |
+| `quit` | Quit the app |
+
+## Submenus
+
+Submenus work the same as Electron's. The id-path resolver walks `submenu` arrays so children are addressable as `parent/child`:
+
+```js
+tray.item({ id: 'account', label: 'Account', submenu: [
+  { id: 'sign-in',  label: 'Sign in',  click: () => {} },
+  { id: 'sign-out', label: 'Sign out', click: () => {} },
+]});
+
+manager.tray.find('account/sign-out');
+manager.tray.update('account/sign-out', { enabled: false });
+manager.tray.appendTo('account', { id: 'profile', label: 'Profile' });
+```
+
+## Item descriptors
+
+Mirror Electron's [`MenuItemConstructorOptions`](https://www.electronjs.org/docs/latest/api/menu#menubuildfromtemplatetemplate), with these additions:
+
+| Field | Type | Notes |
+|---|---|---|
+| `id` | string | Used for id-path lookups (`open`, `quit`, `account/sign-out`, …) |
+| `label` | string \| `() => string` | Function form re-evaluated on every `refresh()` |
+| `enabled` | boolean \| `() => boolean` | Same |
+| `visible` | boolean \| `() => boolean` | Same |
+| `checked` | boolean \| `() => boolean` | Same |
+| `click` | function | Wrapped to swallow errors so a bad handler can't kill the menu |
+| `submenu` | array | Recursively resolved with the same conveniences |
+
+## Runtime API on `manager.tray`
+
+```js
+manager.tray.refresh()                   // re-evaluate dynamic state and re-render
+manager.tray.define(fn)                  // replace the whole definition at runtime
+manager.tray.disable()                   // tear down + stop responding (idempotent)
+manager.tray.setIcon(path)
+manager.tray.setTooltip(text)
+manager.tray.addItem(descriptor)         // append (preserves existing items)
+manager.tray.clearItems()
+manager.tray.destroy()                   // tear down (mostly for tests)
+
+// Id-path API — same as listed above.
+manager.tray.find('quit')
+manager.tray.update('quit', { label: 'Goodbye' })
+manager.tray.remove('website')
+manager.tray.insertAfter('open', { id: 'preferences', label: 'Preferences...', click: ... })
+manager.tray.hide('check-for-updates')
+
+// Inspection
+manager.tray.getItems()                  // shallow copy of raw descriptors
+manager.tray.getIcon()
+manager.tray.getTooltip()
+manager.tray.isRendered()
+```
+
+## Common patterns
+
+### Update label after auth state changes
+
+```js
+// in your renderer/main code, after sign-in:
+manager.storage.set('user', { ... });
+manager.tray.refresh();    // dynamic-label functions re-evaluate
+```
+
+### Hide updater item if you ship without auto-update
+
+```js
+// src/integrations/tray/index.js
+module.exports = ({ tray }) => {
+  tray.icon('...');
+  tray.useDefaults();
+  tray.remove('check-for-updates');
+};
+```
+
+### Replace the entire tray at runtime
+
+```js
+manager.tray.define(({ manager, tray }) => {
+  tray.icon('icons/dark-mode.png');
+  tray.item({ id: 'x', label: 'New layout', click: ... });
+});
+```
+
+## Default scaffold
+
+The scaffold every verb runs ships `src/integrations/tray/index.js` calling `tray.useDefaults()` so you start with the same items the framework would supply on its own — plus commented-out examples covering insertAfter, update, remove, hide, enable, and submenus.

package/docs/usage.md

@@ -0,0 +1,58 @@
+# Usage
+
+Tracks app-launch + hours-of-use stats. Sister of legacy @omega.js/desktop's Usage library, but uses `manager.storage` instead of a separate electron-store.
+
+## What's tracked
+
+```js
+manager.usage.opens()              // total app launches
+manager.usage.hoursTotal()         // cumulative hours-of-use across clean exits
+manager.usage.hoursThisSession()   // live, computed from session start
+manager.usage.installedAt()        // ISO timestamp of first launch
+manager.usage.toJSON()             // all of the above as a structured-cloneable object
+```
+
+## How it accumulates
+
+Persisted shape (`storage.usage`):
+
+```js
+{
+  opens: 12,
+  hoursTotal: 4.75,
+  installedAt: '2025-12-01T...',
+  lastLaunchAt: '...',
+  lastQuitAt: '...' | null,
+}
+```
+
+On boot:
+
+1. Read previous snapshot.
+2. If `lastQuitAt` is set, accumulate `(lastQuitAt - lastLaunchAt)` into `hoursTotal`. This is the "previous session ended cleanly" case.
+3. If `lastQuitAt` is null, the previous session crashed — we don't credit any hours. We don't know how long it ran.
+4. `opens += 1`, `lastLaunchAt = now`, `lastQuitAt = null`.
+
+On quit (via `app.on('before-quit')`):
+
+5. `lastQuitAt = now` written to storage.
+6. Next launch's step 2 picks up the duration.
+
+So `hoursTotal` is intentionally a lower bound — it never over-counts crashed sessions.
+
+`hoursThisSession()` is computed live from `(Date.now() - sessionStart) / 3600000`. Never stale.
+
+## Renderer
+
+```js
+const snap = await window.desktop.usage.get();
+// { opens: 12, hoursTotal: 4.75, hoursThisSession: 0.05, installedAt: '...' }
+```
+
+## Why not just use app-state?
+
+`app-state.js` already tracks `launchCount` (= opens). We could fold these in. But `app-state` is concerned with first-launch / crash-sentinel / version-change semantics — `usage` is concerned with telemetry. Keeping them separate keeps each module focused. Both write to disjoint keys in `manager.storage`.
+
+## Tests
+
+- `src/test/suites/main/usage.test.js` — opens-bumps-on-reinit, hoursTotal accumulation from clean prior session, no-credit for crashed sessions, installedAt persistence, IPC handler.

package/docs/verts.md

@@ -0,0 +1,62 @@
+# Verts — the `data-omega-vert` auto-bind
+
+@omega.js/desktop renderers auto-bind the OMEGA verts (ads) system (monorepo
+`docs/web/ads-system.md`, phase 4): drop a `[data-omega-vert]` element into any
+view and the renderer bootstrap hands it to `@omega.js/client`'s verts module —
+zero consumer JS, same element vocabulary as the web `verts/unit` section and
+@omega.js/extension.
+
+```html
+<div data-omega-vert data-omega-vert-size="banner"></div>
+```
+
+## What the wiring does
+
+`renderer.js _wireAds` (runs inside `manager.initialize()`, same liveness
+model as the FontAwesome/tooltip wiring) binds every `[data-omega-vert]`
+element present at init AND inserted later (MutationObserver), marking bound
+hosts `data-omega-vert-bound="house"`. Everything after the bind lives in the
+client module (`@omega.js/client/modules/verts.js`): lazy arming near the
+viewport, a sandboxed iframe to the resolved in-house source's
+`/omega/verts/serve`, origin-validated postMessage, host-owned rotation +
+staleness recovery, and no-fill collapse (the host hides itself).
+
+## House/company lane ONLY — no AdSense
+
+Desktop surfaces never run the AdSense provider lane (policy: no web
+context). The wiring pins `type: 'house'` on every mount — the pin wins over
+the element's `data-omega-vert` type, so even a shared omega.json5 that carries
+`advertising.providers.adsense` (the web target uses it) can only
+ever reach the house/company inventory here. Pinned by the renderer verts
+suite: an AdSense-configured harness must never see an `adsbygoogle` script
+or `<ins>`.
+
+## Config
+
+The shared `advertising` section of `config/omega.json5` flows into the
+renderer via `OMEGA_BUILD_JSON` like every other section:
+
+```json5
+advertising: {
+  providers: {
+    inhouse: { source: 'company' },  // 'self' | 'company' | full URL
+  },
+  tags: ['music', 'audio-tools'],    // contextual targeting inputs
+}
+```
+
+No `advertising` key (or no resolvable inhouse source) → bound units collapse
+quietly. Nothing else to configure.
+
+## Element vocabulary
+
+| Attribute | Meaning |
+|---|---|
+| `data-omega-vert` | binds the element (type value is ignored on desktop — house pin) |
+| `data-omega-vert-size` | size preset (`banner`/`leaderboard`/`rectangle`/…) or raw px max-height |
+| `data-omega-vert-id` | pin a specific vert |
+| `data-omega-vert-tags` | comma-separated contextual tags for this unit |
+| `data-omega-vert-bound` | set by the wiring (`"house"`) once bound — observability/debugging |
+
+Units emit `omega-vert:fill` / `omega-vert:no-fill` / `omega-vert:click` /
+`omega-vert:reload` CustomEvents on the host (bubbling) for app-side hooks.

package/docs/windows.md

@@ -0,0 +1,149 @@
+# Windows
+
+**Lazy named-window registry.** @omega.js/desktop does NOT auto-create any window. Your `main.js` calls `manager.windows.create('main', { show: !startup.isLaunchHidden() })` from inside `manager.initialize().then(() => { ... })`. Always create `main` — its presence in the registry is what lets @omega.js/desktop's `app.on('activate')` (macOS dock click) and `app.on('second-instance')` (win/linux re-launch) handlers surface UI when the user double-clicks the running app. In hidden launches, pass `show: false` to keep the window invisible until something explicitly calls `windows.show('main')`. Use the registry for the common case (named, persistent, integrated windows). For one-off windows (a toast, a print preview), use `new BrowserWindow()` directly — `window-manager` doesn't get in the way.
+
+## Re-surface on user re-launch
+
+When the user double-clicks a running app (or clicks its dock icon on macOS), @omega.js/desktop transparently shows the main window — no consumer wiring needed.
+
+- **macOS** → `app.on('activate')` calls `windows.show('main')` if `main` is in the registry.
+- **Windows / Linux** → `app.on('second-instance')` does the same. (The OS spawns a duplicate process, the single-instance lock kills it, and the original instance receives the activation.)
+
+Both handlers are no-ops if `main` isn't in the registry. So consumers who genuinely never want a window can omit `windows.create('main', ...)`. Otherwise, the canonical pattern (`windows.create('main', { show: !isLaunchHidden() })`) gives CleanMyMac-style behavior: tray-only at login, full window when the user manually opens the app.
+
+## API
+
+```js
+await manager.windows.create('main', overrides?)        // canonical entry point
+await manager.windows.createNamed('main', mgr, opts?)   // identical; .create() is sugar
+manager.windows.get('main')                              // BrowserWindow | null
+manager.windows.show('main')                             // show + focus + auto app.dock.show()
+manager.windows.hide('main')
+manager.windows.close('main')                            // force-close (bypasses hideOnClose)
+manager.windows.list()                                   // string[] of currently-open names
+```
+
+`create()` is single-instance: a second call with the same name returns the existing window and focuses it (no double-create).
+
+## Defaults
+
+No JSON config required. @omega.js/desktop bakes in sensible defaults so `manager.windows.create('main')` "just works":
+
+| Window | Defaults |
+|---|---|
+| `main`         | `{ width: 1024, height: 720, hideOnClose: true,  view: 'main' }` |
+| any other name | `{ width: 800,  height: 600, hideOnClose: false, view: name   }` |
+
+Override at the call site:
+
+```js
+manager.windows.create('main',     { width: 1280, height: 800 });
+manager.windows.create('settings', { width: 600,  height: 480 });
+```
+
+## Config (optional)
+
+If you want to override defaults persistently (without typing them at every `create()` call), add a `windows:` block to `config/omega.json5`:
+
+```jsonc
+"windows": {
+  "main": { "width": 1280, "height": 800 }
+}
+```
+
+Merge order: **framework defaults < JSON config < call-site overrides**.
+
+Per-window keys:
+
+| Key | Default (main) | Default (other) | Description |
+|---|---|---|---|
+| `view` | `main` | `<name>` | Folder under `src/views/`. Loads `dist/views/<view>/index.html`. |
+| `width` / `height` | 1024 / 720 | 800 / 600 | Initial size (overridden by saved bounds if `persistBounds: true`). |
+| `minWidth` / `minHeight` | 400 / 300 | 400 / 300 | |
+| `show` | `true` | `true` | Auto-show on `ready-to-show`. `false` keeps the window hidden until `manager.windows.show()`. |
+| `hideOnClose` | `true` | `false` | Discord-style: X click hides instead of closes. See "Hide-on-close" below. |
+| `title` | `app.productName` | `app.productName` | Window title. |
+| `backgroundColor` | `#ffffff` | `#ffffff` | Background color before the page loads. |
+| `persistBounds` | `true` | `true` | Remember position+size across launches (see below). |
+| `skipTaskbar` | `false` | `false` | Suppress taskbar/dock entry for THIS window. |
+| `titleBar` | `'inset'` | `'inset'` | `'inset'` (mac/win native overlay) or `'native'` (full system frame). |
+| `titleBarOverlay` | platform default | platform default | Override Windows overlay color/symbolColor/height. |
+| `trafficLightPosition` | OS inset default | OS inset default | macOS only: `{ x, y }` custom position for the traffic lights (e.g. to center them inside a floating chrome panel). Only applies in `'inset'` mode. |
+
+## Inset titlebar (default)
+
+@omega.js/desktop ships an inset titlebar by default — the OS draws all the window controls and @omega.js/desktop adds a draggable strip in the page template:
+
+| Platform | Behavior |
+|---|---|
+| **macOS** | `titleBarStyle: 'hiddenInset'` — traffic lights inset into the chrome region. Reposition them via `config.windows.<name>.trafficLightPosition = { x, y }` (e.g. when the app draws a floating chrome panel and the lights should sit inside it). |
+| **Windows** | `titleBarStyle: 'hidden'` + `titleBarOverlay: { color, symbolColor, height: 36 }` — native min/max/close buttons drawn by the OS |
+| **Linux** | Native frame (full system title bar) |
+
+The page template (`<em>/src/config/page-template.html`, framework-internal — not consumer-overrideable) ships an `.omega-titlebar` div with `-webkit-app-region: drag`. Per-platform spacing is handled by `themes/classy/css/components/_titlebar.scss`, which keys off `html[data-platform]` (set by @omega.js/client during init):
+
+- **mac** → `padding-left: 70px` (clear the traffic lights)
+- **windows** → `padding-right: 140px` (clear the native overlay)
+- **linux** → `display: none` (native frame draws title bar)
+
+Override per-window via `config.windows.<name>.titleBar = 'native'` to opt out and get a full system frame on every platform.
+
+## Hide-on-close (Discord-style)
+
+The `main` window's X button **hides instead of closes** by default. Real quit only via:
+
+- `Cmd+Q` (macOS standard `role: 'quit'` accelerator)
+- Menu Quit (`main/quit` on mac, `file/quit` on win/linux)
+- Tray Quit (`quit` item)
+- Auto-updater install (`autoUpdater.installNow()`)
+- Programmatic `manager.quit({ force: true })`
+
+The window-manager close handler checks three flags before deciding to swallow vs let through:
+
+| Flag | Set by | Means |
+|---|---|---|
+| `manager._allowQuit` | `manager.quit({ force: true })`, `autoUpdater.installNow()` | Programmatic force — let the close go through. |
+| `manager._isQuitting` | `app.on('before-quit')` (every quit path Electron knows about) | App is quitting — let close events flow naturally. |
+| `win._emForceClose` | `manager.windows.close(name)` | Per-window override. |
+
+Other named windows default to `hideOnClose: false` (X actually closes). Override per window via config or call-site overrides.
+
+## Bounds persistence
+
+Every named window's position and size persist to storage on resize / move / maximize / unmaximize / fullscreen-enter / fullscreen-leave / close. Restored on next `create()`.
+
+- Storage key: `windows.<name>.bounds`
+- Saves debounced 250ms; close flushes synchronously.
+- Off-screen detection: if a saved position has less than 100×50px overlap with any current display's `workArea`, position is dropped (size kept). Handles "monitor unplugged" gracefully.
+- Maximized / fullscreen state is stored separately and restored via `win.maximize()` / `win.setFullScreen(true)`.
+- Sanity floor: saved entries with `width < 100` or `height < 100` are ignored.
+- Opt out per-window: `persistBounds: false`.
+
+## macOS dock auto-show
+
+When `LSUIElement: true` is baked at build time (`startup.mode: 'hidden'`), the app launches with **no dock icon, no Cmd+Tab, no taskbar**. The first time `manager.windows.create()` or `manager.windows.show()` runs, @omega.js/desktop calls `app.dock.show()` automatically — the dock icon appears alongside the window.
+
+**And the inverse**: for `startup.mode: 'hidden'` apps, when the LAST visible named window hides (hide-on-close X, `windows.hide()`, any consumer `win.hide()`), @omega.js/desktop calls `app.dock.hide()` again — the app returns to its fully-invisible posture, dock and UI appearing and vanishing together. Normal-mode apps keep their dock icon for life; quit paths are untouched (`manager._isQuitting` guard).
+
+This means agent / menubar apps can stay completely invisible until the user explicitly asks for UI:
+
+```js
+manager.initialize().then(() => {
+  // Don't call windows.create() here — app stays invisible.
+  // Surface UI later when something warrants it:
+  manager.tray.update('open', { click: () => manager.windows.create('main') });
+});
+```
+
+## Auto-attach context-menu
+
+Every window created via `manager.windows.create()` is automatically wired up with the consumer's `src/integrations/context-menu/index.js` (see [context-menu.md](context-menu.md)). Idempotent per webContents (uses a WeakSet). For windows you create directly with `new BrowserWindow()`, call `manager.contextMenu.attach(win.webContents)` manually.
+
+## Testing mode: stealth surfacing
+
+When `manager.isTesting()` (i.e. under `npx omega test`), every surfacing path in this lib — `ready-to-show`, `windows.show()`, the create-dedup focus — goes **stealth** instead of `win.show()`: `_surface()` applies the shared recipe from `src/utils/stealth-window.js` and surfaces via `showInactive()`, with no `win.focus()`/dock surfacing. **The full stealth story lives in [test-framework.md](test-framework.md) (SSOT)** — the recipe and why it's not `hide()`/`minimize()`, the raw-window `browser-window-created` hook, `webContents.focus()` suppression, macOS app-level activation suppression, and the **`OMEGA_TEST_SHOW=1`** opt-out. Covered by `suites/main/stealth-window.test.js`.
+
+## Platform behavior
+
+- `window-all-closed` → `app.quit()` on Windows/Linux only. macOS apps are sticky (stay running with no windows).
+- All event listeners (`close` / `closed` / `resize` / `move` / `ready-to-show` / etc.) are attached **before** `await loadFile()` resolves, so the window is fully observable the moment it lands in the registry.

package/package.json

@@ -0,0 +1,184 @@
+{
+  "name": "@omega.js/desktop",
+  "version": "0.1.0",
+  "description": "OMEGA desktop framework — build, test, and package Electron apps for macOS, Windows, and Linux",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./config": "./dist/vendor/config/index.js",
+    "./gulp": "./dist/gulp/main.js",
+    "./main": "./dist/main.js",
+    "./renderer": "./dist/renderer.js",
+    "./preload": "./dist/preload.js",
+    "./build": "./dist/build.js",
+    "./test": "./dist/test/index.js",
+    "./hooks/notarize": "./dist/hooks/notarize.js",
+    "./lib/app-state": "./dist/lib/app-state.js",
+    "./lib/auto-updater": "./dist/lib/auto-updater.js",
+    "./lib/context-menu": "./dist/lib/context-menu.js",
+    "./lib/deep-link": "./dist/lib/deep-link.js",
+    "./lib/ipc": "./dist/lib/ipc.js",
+    "./lib/logger": "./dist/lib/logger.js",
+    "./lib/logger-lite": "./dist/lib/logger-lite.js",
+    "./lib/menu": "./dist/lib/menu.js",
+    "./lib/protocol": "./dist/lib/protocol.js",
+    "./lib/restart-manager": "./dist/lib/restart-manager/index.js",
+    "./lib/restart-manager/protocol": "./dist/lib/restart-manager/protocol.js",
+    "./lib/startup": "./dist/lib/startup.js",
+    "./lib/storage": "./dist/lib/storage.js",
+    "./lib/templating": "./dist/lib/templating.js",
+    "./lib/tray": "./dist/lib/tray.js",
+    "./lib/client-bridge": "./dist/lib/client-bridge.js",
+    "./lib/window-manager": "./dist/lib/window-manager.js",
+    "./cli": "./dist/cli-run.js",
+    "./scripts/sync-nvmrc": "./scripts/sync-nvmrc.js"
+  },
+  "bin": {
+    "omega": "./bin/omega",
+    "omg": "./bin/omg",
+    "mgr": "./bin/omega",
+    "omega-desktop": "./bin/omega-desktop"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "docs/",
+    "scripts/"
+  ],
+  "preparePackage": {
+    "input": "./src",
+    "output": "./dist",
+    "type": "copy",
+    "replace": {},
+    "hooks": {
+      "after": [
+        "node -e \"require('@omega.js/devkit/vendor')()\"",
+        "node -e \"require('@omega.js/devkit/prepare-guard').rewire()\""
+      ],
+      "afterBlocking": true
+    }
+  },
+  "omega": {
+    "nodeRuntime": "24",
+    "vendorAssets": [
+      {
+        "package": "@omega.js/web",
+        "from": "core/css/tokens/_index.scss",
+        "to": "assets/css/tokens/_index.scss"
+      },
+      {
+        "package": "@omega.js/web",
+        "from": "core/css/shell",
+        "to": "assets/css/shell"
+      },
+      {
+        "package": "@omega.js/web",
+        "from": "core/css/core/_custom-font-awesome.scss",
+        "to": "assets/css/core/_fontawesome.scss"
+      },
+      {
+        "package": "@omega.js/web",
+        "from": "core/js/core/app-shell.js",
+        "to": "assets/js/core/app-shell.js"
+      },
+      {
+        "package": "@omega.js/web",
+        "from": "themes",
+        "to": "assets/themes"
+      }
+    ]
+  },
+  "scripts": {
+    "start": "npm run prepare:watch",
+    "prepare": "node -e \"require('@omega.js/devkit/prepare-guard')() && require('prepare-package')()\"",
+    "prepare:watch": "node -e \"require('prepare-package/watch')()\"",
+    "test": "node ./bin/omega-desktop test"
+  },
+  "projectScripts": {
+    "start": "omega clean && npm run gulp --",
+    "gulp": "gulp",
+    "build": "omega build",
+    "package": "omega package",
+    "package:quick": "omega package --quick",
+    "publish": "omega publish",
+    "release": "omega release",
+    "release:local": "omega publish --local",
+    "postinstall": "node -e \"try { require('@omega.js/desktop/scripts/sync-nvmrc') } catch (e) {}\"",
+    "test": "omega test",
+    "electron": "electron ."
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "omega",
+    "electron",
+    "desktop-app",
+    "cross-platform",
+    "electron-builder",
+    "electron-updater",
+    "auto-update",
+    "gulp",
+    "sass",
+    "esbuild"
+  ],
+  "author": "ITW Creative Works",
+  "license": "Elastic-2.0",
+  "peerDependencies": {
+    "electron": ">=42",
+    "electron-builder": ">=26",
+    "gulp": "^5.0.1"
+  },
+  "devDependencies": {
+    "@electron/notarize": "^3.1.1",
+    "@omega.js/analytics": "*",
+    "@omega.js/config": "*",
+    "@omega.js/devkit": "*",
+    "@omega.js/monitoring": "*",
+    "@omega.js/web": "*",
+    "electron": "^42.0.1",
+    "electron-builder": "^26.8.1",
+    "firebase-admin": "^13.9.0",
+    "prepare-package": "^2.2.0"
+  },
+  "dependencies": {
+    "@fortawesome/fontawesome-free": "^7.3.0",
+    "@inquirer/prompts": "^8.5.2",
+    "@octokit/rest": "^22.0.1",
+    "@omega.js/client": "0.1.0",
+    "@popperjs/core": "^2.11.8",
+    "@sentry/electron": "^7.13.0",
+    "chalk": "^5.6.2",
+    "dotenv": "^17.4.2",
+    "electron-log": "^5.4.3",
+    "electron-store": "^11.0.2",
+    "electron-updater": "^6.8.3",
+    "esbuild": "^0.28.1",
+    "extract-zip": "^2.0.1",
+    "fs-jetpack": "^5.1.0",
+    "glob": "^13.0.6",
+    "gulp-clean-css": "^4.3.0",
+    "gulp-rename": "^2.1.0",
+    "gulp-responsive-modern": "^1.0.0",
+    "gulp-sass": "^6.0.1",
+    "js-yaml": "^4.1.1",
+    "json5": "^2.2.3",
+    "lodash": "^4.18.1",
+    "minimatch": "^10.2.5",
+    "node-powertools": "^3.0.0",
+    "plist": "^4.0.0",
+    "sass": "^1.99.0",
+    "uuid": "^14.0.0",
+    "wonderful-fetch": "^2.0.5",
+    "wonderful-version": "^1.3.2",
+    "ws": "^8.20.0",
+    "yargs": "^18.0.0"
+  },
+  "optionalDependencies": {
+    "automately": "^1.0.5"
+  }
+}