@edenapp/types 0.1.2 → 0.1.4

package/AppManifest.d.ts

@@ -1,3 +1,5 @@
+import type { ServiceDeclaration } from "./channels";
+
 /**
  * Window Mode Configuration
  *
@@ -5,9 +7,22 @@
  */
 export type WindowMode = "floating" | "tiled" | "both";
 
+/**
+ * CSS injection mode for app views
+ * - "full": Inject complete CSS (tokens + utilities + components)
+ * - "tokens": Inject only CSS custom property definitions
+ * - "none": Don't inject any CSS
+ */
+export type CSSInjectionMode = "full" | "tokens" | "none";
+
 export interface WindowInjectionOptions {
-  /** Inject the Eden design system CSS into the view (default: true) */
-  css?: boolean;
+  /**
+   * Control Eden CSS injection (default: "full")
+   * - "full": Complete CSS including tokens, utilities, and components
+   * - "tokens": Only CSS custom property definitions (variables)
+   * - "none": No CSS injection
+   */
+  css?: CSSInjectionMode;
 
   /** Inject the Eden app frame with title bar controls (default: true) */
   appFrame?: boolean;
@@ -54,6 +69,89 @@ export interface WindowConfig {
   injections?: WindowInjectionOptions;
 }
 
+/**
+ * File handler configuration for apps that can open files
+ */
+export interface FileHandlerConfig {
+  /** Display name for this handler (e.g., "Text Documents") */
+  name: string;
+
+  /** File extensions this handler supports (without dot, e.g., ["txt", "md"]) */
+  extensions: string[];
+
+  /** MIME types this handler supports (optional) */
+  mimeTypes?: string[];
+
+  /** Icon for this handler (optional) */
+  icon?: string;
+}
+
+/**
+ * Supported setting input types
+ */
+export type SettingType =
+  | "text"
+  | "number"
+  | "checkbox"
+  | "radio"
+  | "select"
+  | "toggle"
+  | "textarea"
+  | "color"
+  | "range";
+
+/**
+ * Option for radio/select settings
+ */
+export interface SettingOption {
+  /** Value stored when this option is selected */
+  value: string;
+  /** Display label for this option */
+  label: string;
+  /** Optional description for this option */
+  description?: string;
+}
+
+/**
+ * Individual setting definition
+ */
+export interface SettingDefinition {
+  /** Unique key for this setting */
+  key: string;
+  /** Display label */
+  label: string;
+  /** Description shown as help text */
+  description?: string;
+  /** Input type */
+  type: SettingType;
+  /** Default value (as string, will be parsed based on type) */
+  defaultValue?: string;
+  /** Options for radio/select types */
+  options?: SettingOption[];
+  /** Placeholder for text/textarea */
+  placeholder?: string;
+  /** Min value for number/range */
+  min?: number;
+  /** Max value for number/range */
+  max?: number;
+  /** Step for number/range */
+  step?: number;
+}
+
+/**
+ * Settings category (group of related settings)
+ */
+export interface SettingsCategory {
+  /** Category ID */
+  id: string;
+  /** Display name */
+  name: string;
+  /** Category icon (optional) */
+  icon?: string;
+  /** Settings in this category */
+  settings: SettingDefinition[];
+}
+
 /**
  * App Manifest Interface
  *
@@ -92,11 +190,23 @@ export interface AppManifest {
     };
   };
 
-  /** Frontend configuration */
-  frontend: {
+  /**
+   * Frontend configuration.
+   * Optional - omit for backend-only apps (daemons).
+   * At least one of `frontend` or `backend` must be defined.
+   */
+  frontend?: {
     /** Path to the frontend HTML entry file */
     entry: string;
 
+    /**
+     * Allow remote URLs to be embedded in iframes.
+     * When true, strips X-Frame-Options and CSP frame-ancestors headers
+     * that would otherwise prevent embedding.
+     * Only applies to remote (http/https) frontend entries.
+     */
+    allowEmbedding?: boolean;
+
     /** WebContentsView options */
     options?: {
       /** Enable Node.js integration in the view (default: false) */
@@ -120,9 +230,41 @@ export interface AppManifest {
   build?: {
     /** Command to build the app (e.g., "npm run build") */
     command: string;
+    /** Working directory for build command (relative to app root) */
+    cwd?: string;
   };
 
   /** Internal flag indicating if this is a prebuilt system app */
   isPrebuilt?: boolean;
-}
 
+  /**
+   * Permissions requested by this app.
+   * Supports glob patterns: "fs/*" for all fs permissions, "*" for all permissions.
+   */
+  permissions?: string[];
+
+  /**
+   * File types this app can handle.
+   * Used for "open with" functionality and automatic handler detection.
+   */
+  fileHandlers?: FileHandlerConfig[];
+
+  /**
+   * Whether this app runs as a system overlay.
+   * Overlays are rendered above regular apps.
+   */
+  overlay?: boolean;
+
+  /**
+   * Services this app exposes for other apps to connect to.
+   * Declaring services here documents the app's API and enables
+   * optional access control via allowedClients.
+   */
+  services?: ServiceDeclaration[];
+
+  /**
+   * App settings configuration.
+   * Defines settings categories and individual settings that can be configured.
+   */
+  settings?: SettingsCategory[];
+}

package/EdenConfig.d.ts

@@ -33,4 +33,7 @@ export interface EdenConfig {
   };
   tiling?: TilingConfig;
   development?: boolean;
+
+  /** List of app IDs to start automatically when Eden launches */
+  autostart?: string[];
 }

package/README.md

@@ -17,9 +17,7 @@ To enable type support for window APIs, update your `tsconfig.json` to include:
 ```json
 {
   "compilerOptions": {
-    "types": [
-      "@edenapp/types/global"
-    ]
+    "types": ["@edenapp/types/global"]
   }
 }
 ```
@@ -30,15 +28,7 @@ Import types in your Eden app:
 
 ```typescript
 // Use Eden API in your app's frontend
-const files = await window.edenAPI!.shellCommand('fs/readdir', {
-  path: '/home/user/documents'
+const files = await window.edenAPI.shellCommand("fs/readdir", {
+  path: "/home/user/documents",
 });
 ```
-
-## Documentation
-
-For complete Eden platform documentation, visit the main [Eden repository](https://github.com/b0czek/eden).
-
-## License
-
-MIT

package/channels.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AppBus Channel Types
+ *
+ * Types for the app-to-app communication system (Eden AppBus)
+ */
+
+/**
+ * Service declaration in app manifest
+ */
+export interface ServiceDeclaration {
+  /** Service name (must be unique per app) */
+  name: string;
+  /** Human-readable description */
+  description?: string;
+  /** Optional: Restrict which apps can connect (if omitted, open to all) */
+  allowedClients?: string[];
+}
+
+/**
+ * Result of a connect attempt
+ */
+export interface ConnectResult {
+  success: boolean;
+  error?: string;
+  /** Connection ID (for internal tracking) */
+  connectionId?: string;
+}
+
+/**
+ * Registered service with internal details
+ */
+export interface RegisteredService {
+  appId: string;
+  serviceName: string;
+  description?: string;
+  allowedClients?: string[];
+  webContentsId?: number;
+  providerType: "frontend" | "backend";
+}

package/commands.generated.d.ts

@@ -14,7 +14,222 @@ export interface SystemCommands {
    */
   "system/info": {
     args: Record<string, never>;
-    response: SystemInfo;
+    response: import("./index").SystemInfo;
+  };
+}
+
+/**
+ * AppbusCommands - Commands for the "appbus" namespace
+ */
+export interface AppbusCommands {
+  /**
+   * Register a service that this app exposes
+   * Requires "appbus/expose" permission
+   */
+  "appbus/register": {
+    args: {
+    serviceName: string;
+    description?: string;
+    allowedClients?: string[] };
+    response: { success: boolean; error?: string };
+  };
+  /**
+   * Unregister a service
+   * Requires "appbus/expose" permission
+   */
+  "appbus/unregister": {
+    args: {
+    serviceName: string };
+    response: { success: boolean };
+  };
+  /**
+   * List all available services
+   * No permission required
+   */
+  "appbus/list": {
+    args: Record<string, never>;
+    response: { services: import("./index").ServiceInfo[] };
+  };
+  /**
+   * List services by app ID
+   * No permission required
+   */
+  "appbus/list-by-app": {
+    args: {
+    appId: string };
+    response: { services: import("./index").ServiceInfo[] };
+  };
+  /**
+   * Connect to another app's service
+   * Creates MessageChannel and transfers ports directly to both apps
+   * Requires "appbus/connect" permission
+   */
+  "appbus/connect": {
+    args: {
+    targetAppId: string;
+    serviceName: string };
+    response: import("./index").ConnectResult;
+  };
+}
+
+/**
+ * DbCommands - Commands for the "db" namespace
+ */
+export interface DbCommands {
+  /**
+   * Get a value from database (scoped to caller's app)
+   */
+  "db/get": {
+    args: {
+    key: string };
+    response: { value: string | undefined };
+  };
+  /**
+   * Set a value in database (scoped to caller's app)
+   */
+  "db/set": {
+    args: {
+    key: string;
+    value: string };
+    response: { success: boolean };
+  };
+  /**
+   * Delete a key from database (scoped to caller's app)
+   */
+  "db/delete": {
+    args: {
+    key: string };
+    response: { success: boolean };
+  };
+  /**
+   * Check if a key exists (scoped to caller's app)
+   */
+  "db/has": {
+    args: {
+    key: string };
+    response: { exists: boolean };
+  };
+  /**
+   * Clear all keys (scoped to caller's app)
+   */
+  "db/clear": {
+    args: { };
+    response: { success: boolean };
+  };
+  /**
+   * List all keys (scoped to caller's app)
+   */
+  "db/list": {
+    args: { };
+    response: { keys: string[] };
+  };
+  /**
+   * Get a value from any app's namespace (superuser only)
+   */
+  "db/get/su": {
+    args: {
+    appId: string;
+    key: string };
+    response: { value: string | undefined };
+  };
+  /**
+   * Set a value in any app's namespace (superuser only)
+   */
+  "db/set/su": {
+    args: {
+    appId: string;
+    key: string;
+    value: string };
+    response: { success: boolean };
+  };
+  /**
+   * Delete a key from any app's namespace (superuser only)
+   */
+  "db/delete/su": {
+    args: {
+    appId: string;
+    key: string };
+    response: { success: boolean };
+  };
+  /**
+   * Check if a key exists in any app's namespace (superuser only)
+   */
+  "db/has/su": {
+    args: {
+    appId: string;
+    key: string };
+    response: { exists: boolean };
+  };
+  /**
+   * Clear all keys in any app's namespace (superuser only)
+   */
+  "db/clear/su": {
+    args: {
+    appId: string };
+    response: { success: boolean };
+  };
+  /**
+   * List all keys in any app's namespace (superuser only)
+   */
+  "db/list/su": {
+    args: {
+    appId: string };
+    response: { keys: string[] };
+  };
+}
+
+/**
+ * FileCommands - Commands for the "file" namespace
+ */
+export interface FileCommands {
+  /**
+   * Open a file with its default handler
+   */
+  "file/open": {
+    args: { path: string };
+    response: import("./index").FileOpenResult;
+  };
+  /**
+   * Open a file with a specific app
+   */
+  "file/open-with": {
+    args: { path: string; appId: string };
+    response: import("./index").FileOpenResult;
+  };
+  /**
+   * Get the default handler app for a file extension
+   */
+  "file/get-handler": {
+    args: { extension: string };
+    response: { appId: string | undefined };
+  };
+  /**
+   * Set user preference for a file extension's default handler
+   */
+  "file/set-default-handler": {
+    args: { extension: string; appId: string };
+    response: void;
+  };
+  /**
+   * Remove user preference for a file extension (revert to default)
+   */
+  "file/remove-default-handler": {
+    args: { extension: string };
+    response: void;
+  };
+  /**
+   * Get all apps that can handle a specific file extension
+   */
+  "file/get-supported-handlers": {
+    args: { extension: string };
+    response: import("./index").FileHandlerInfo[];
+  };
+  /**
+   * Get all file type associations
+   */
+  "file/get-associations": {
+    args: Record<string, never>;
+    response: Record<string, { default: string | undefined; userOverride: string | undefined }>;
   };
 }
 
@@ -28,8 +243,7 @@ export interface FsCommands {
   "fs/read": {
     args: {
     path: string;
-    encoding?: BufferEncoding;
-  };
+    encoding?: string };
     response: string;
   };
   /**
@@ -39,8 +253,7 @@ export interface FsCommands {
     args: {
     path: string;
     content: string;
-    encoding?: BufferEncoding;
-  };
+    encoding?: string };
     response: void;
   };
   /**
@@ -69,12 +282,7 @@ export interface FsCommands {
    */
   "fs/stat": {
     args: { path: string };
-    response: {
-    isFile: boolean;
-    isDirectory: boolean;
-    size: number;
-    mtime: Date;
-  };
+    response: import("./index").FileStats;
   };
   /**
    * Search for files and directories using glob patterns.
@@ -83,13 +291,8 @@ export interface FsCommands {
     args: {
     path: string;
     pattern: string;
-    limit?: number;
-  };
-    response: Array<{
-      name: string;
-      path: string;
-      type: "file" | "folder";
-    }>;
+    limit?: number };
+    response: import("./index").SearchResult[];
   };
   /**
    * Delete a file or directory.
@@ -101,6 +304,47 @@ export interface FsCommands {
   };
 }
 
+/**
+ * EventCommands - Commands for the "event" namespace
+ */
+export interface EventCommands {
+  "event/subscribe": {
+    args: {
+    eventName: string;
+    _callerWebContentsId?: number;
+    _callerAppId?: string };
+    response: void;
+  };
+  "event/unsubscribe": {
+    args: {
+    eventName: string;
+    _callerWebContentsId?: number;
+    _callerAppId?: string };
+    response: void;
+  };
+  "event/exists": {
+    args: { eventName: string };
+    response: boolean;
+  };
+}
+
+/**
+ * NotificationCommands - Commands for the "notification" namespace
+ */
+export interface NotificationCommands {
+  /**
+   * Push a new notification to subscribers.
+   */
+  "notification/push": {
+    args: {
+    title: string;
+    message: string;
+    timeout?: number;
+    type?: import("./index").NotificationType };
+    response: import("./index").Notification;
+  };
+}
+
 /**
  * PackageCommands - Commands for the "package" namespace
  */
@@ -110,7 +354,7 @@ export interface PackageCommands {
    */
   "package/install": {
     args: { sourcePath: string };
-    response: AppManifest;
+    response: import("./index").AppManifest;
   };
   /**
    * Uninstall an application by its ID.
@@ -121,25 +365,36 @@ export interface PackageCommands {
   };
   /**
    * List all installed applications.
+   * @param showHidden - If true, includes overlay apps (hidden by default)
    */
-  "package/list-installed": {
-    args: Record<string, never>;
-    response: AppManifest[];
+  "package/list": {
+    args: { showHidden?: boolean };
+    response: import("./index").AppManifest[];
   };
   /**
    * Toggle hot reload for an app
    */
   "package/toggle-hot-reload": {
-    args: { appId: string };
+    args: {
+    appId: string };
     response: { enabled: boolean };
   };
   /**
    * Check if hot reload is enabled for an app
    */
   "package/is-hot-reload-enabled": {
-    args: { appId: string };
+    args: {
+    appId: string };
     response: { enabled: boolean };
   };
+  /**
+   * Get the icon for an installed application as a data URL.
+   */
+  "package/get-icon": {
+    args: {
+    appId: string };
+    response: { icon: string | undefined };
+  };
 }
 
 /**
@@ -152,9 +407,8 @@ export interface ProcessCommands {
   "process/launch": {
     args: {
     appId: string;
-    bounds?: ViewBounds;
-  };
-    response: LaunchResult;
+    bounds?: import("./index").ViewBounds };
+    response: import("./index").LaunchResult;
   };
   /**
    * Stop a running application instance.
@@ -165,10 +419,109 @@ export interface ProcessCommands {
   };
   /**
    * List all running application processes.
+   * @param showHidden - If true, includes overlay apps (hidden by default)
    */
   "process/list": {
+    args: { showHidden?: boolean };
+    response: import("./index").AppInstance[];
+  };
+}
+
+/**
+ * SettingsCommands - Commands for the "settings" namespace
+ */
+export interface SettingsCommands {
+  /**
+   * Get a setting value (scoped to caller's app)
+   */
+  "settings/get": {
+    args: {
+    key: string };
+    response: { value: string | undefined };
+  };
+  /**
+   * Set a setting value (scoped to caller's app)
+   */
+  "settings/set": {
+    args: {
+    key: string;
+    value: string };
+    response: { success: boolean };
+  };
+  /**
+   * List all settings keys (scoped to caller's app)
+   */
+  "settings/list": {
+    args: { };
+    response: { keys: string[] };
+  };
+  /**
+   * Get all settings with values (scoped to caller's app)
+   */
+  "settings/get-all": {
+    args: { };
+    response: { settings: Record<string, string> };
+  };
+  /**
+   * Reset a setting to default (scoped to caller's app)
+   */
+  "settings/reset": {
+    args: {
+    key: string;
+    schema?: import("./index").SettingsCategory[] };
+    response: { success: boolean };
+  };
+  /**
+   * Get a setting from any app's namespace (superuser only)
+   */
+  "settings/get/su": {
+    args: {
+    appId: string;
+    key: string };
+    response: { value: string | undefined };
+  };
+  /**
+   * Set a setting in any app's namespace (superuser only)
+   */
+  "settings/set/su": {
+    args: {
+    appId: string;
+    key: string;
+    value: string };
+    response: { success: boolean };
+  };
+  /**
+   * List all settings in any app's namespace (superuser only)
+   */
+  "settings/list/su": {
+    args: {
+    appId: string };
+    response: { keys: string[] };
+  };
+  /**
+   * Get all settings with values for any app (superuser only)
+   */
+  "settings/get-all/su": {
+    args: {
+    appId: string };
+    response: { settings: Record<string, string> };
+  };
+  /**
+   * Reset a setting for any app (superuser only)
+   */
+  "settings/reset/su": {
+    args: {
+    appId: string;
+    key: string;
+    schema?: import("./index").SettingsCategory[] };
+    response: { success: boolean };
+  };
+  /**
+   * Get the Eden settings schema
+   */
+  "settings/schema": {
     args: Record<string, never>;
-    response: AppStatus;
+    response: { schema: import("./index").SettingsCategory[] };
   };
 }
 
@@ -182,8 +535,7 @@ export interface ViewCommands {
   "view/update-view-bounds": {
     args: {
     appId: string;
-    bounds: ViewBounds;
-  };
+    bounds: import("./index").ViewBounds };
     response: { success: boolean };
   };
   /**
@@ -192,8 +544,7 @@ export interface ViewCommands {
   "view/set-view-visibility": {
     args: {
     appId: string;
-    visible: boolean;
-  };
+    visible: boolean };
     response: { success: boolean };
   };
   /**
@@ -208,9 +559,8 @@ export interface ViewCommands {
    */
   "view/update-global-bounds": {
     args: {
-    bounds: ViewBounds;
-    windowSize: WindowSize;
-  };
+    bounds: import("./index").ViewBounds;
+    windowSize: import("./index").WindowSize };
     response: { success: boolean };
   };
   /**
@@ -219,8 +569,7 @@ export interface ViewCommands {
   "view/toggle-view-mode": {
     args: {
     appId: string;
-    mode?: "floating" | "tiled";
-  };
+    mode?: "floating" | "tiled" };
     response: { success: boolean };
   };
   /**
@@ -230,8 +579,7 @@ export interface ViewCommands {
     args: {
     appId: string;
     startX: number;
-    startY: number;
-  };
+    startY: number };
     response: { success: boolean };
   };
   /**
@@ -255,8 +603,7 @@ export interface ViewCommands {
     args: {
     appId: string;
     startX: number;
-    startY: number;
-  };
+    startY: number };
     response: { success: boolean };
   };
   /**
@@ -264,8 +611,7 @@ export interface ViewCommands {
    */
   "view/end-resize": {
     args: {
-    appId: string;
-  };
+    appId: string };
     response: { success: boolean };
   };
   /**
@@ -273,45 +619,11 @@ export interface ViewCommands {
    */
   "view/window-size": {
     args: Record<string, never>;
-    response: WindowSize;
+    response: import("./index").WindowSize;
   };
 }
 
 /**
  * Global command map - merge all command namespaces
  */
-export interface CommandMap extends SystemCommands, FsCommands, PackageCommands, ProcessCommands, ViewCommands {}
-
-/**
- * Array of all available command names
- */
-export const COMMAND_NAMES = [
-  "system/info",
-  "fs/read",
-  "fs/write",
-  "fs/exists",
-  "fs/mkdir",
-  "fs/readdir",
-  "fs/stat",
-  "fs/search",
-  "fs/delete",
-  "package/install",
-  "package/uninstall",
-  "package/list-installed",
-  "package/toggle-hot-reload",
-  "package/is-hot-reload-enabled",
-  "process/launch",
-  "process/stop",
-  "process/list",
-  "view/update-view-bounds",
-  "view/set-view-visibility",
-  "view/focus-app",
-  "view/update-global-bounds",
-  "view/toggle-view-mode",
-  "view/start-drag",
-  "view/end-drag",
-  "view/global-mouseup",
-  "view/start-resize",
-  "view/end-resize",
-  "view/window-size"
-] as const;
+export interface CommandMap extends SystemCommands, AppbusCommands, DbCommands, FileCommands, FsCommands, EventCommands, NotificationCommands, PackageCommands, ProcessCommands, SettingsCommands, ViewCommands {}

package/events.d.ts

@@ -1,9 +1,9 @@
 /**
  * AppEvents - Events sent from backend to renderer
- * 
+ *
  * All events are sent via the unified 'shell-message' channel.
  * Views must subscribe to specific events to receive them.
- * 
+ *
  * This file re-exports auto-generated event types.
  * Event definitions are automatically generated from @EdenNamespace decorators.
  * Run 'npm run codegen' to regenerate.
@@ -11,8 +11,11 @@
 
 export * from "./events.generated";
 
+import { AppEvents } from "./events.generated";
+
 /**
  * Utility types for working with AppEvents
  */
-export type EventName = (typeof import("./events.generated").APP_EVENT_NAMES)[number];
-export type EventData<T extends EventName> = import("./events.generated").AppEvents[T];
+export type EventName = keyof AppEvents;
+export type EventData<T extends EventName> =
+  import("./events.generated").AppEvents[T];

package/events.generated.d.ts

@@ -2,14 +2,29 @@
  * AUTO-GENERATED FILE - DO NOT EDIT
  * 
  * This file is automatically generated by scripts/generate-commands.ts
- * Run 'npm run codegen' to regenerate.
+ * Run 'pnpm run codegen' to regenerate.
  */
 
+/**
+ * FileEvents - Events for the "file" namespace
+ */
+export interface FileEvents {
+  "file/opened": { path: string; isDirectory: boolean; appId: string };
+}
+
+/**
+ * NotificationEvents - Events for the "notification" namespace
+ */
+export interface NotificationEvents {
+  "notification/added": { notification: import("./index").Notification };
+  "notification/removed": { id: string };
+}
+
 /**
  * PackageEvents - Events for the "package" namespace
  */
 export interface PackageEvents {
-  "package/installed": { manifest: AppManifest };
+  "package/installed": { manifest: import("./index").AppManifest };
   "package/uninstalled": { appId: string };
 }
 
@@ -17,35 +32,39 @@ export interface PackageEvents {
  * ProcessEvents - Events for the "process" namespace
  */
 export interface ProcessEvents {
-  "process/launched": { instance: AppInstance };
+  "process/launched": { instance: import("./index").AppInstance };
   "process/stopped": { appId: string };
   "process/error": { appId: string; error: any };
   "process/exited": { appId: string; code: number };
 }
 
+/**
+ * SettingsEvents - Events for the "settings" namespace
+ */
+export interface SettingsEvents {
+  "settings/changed": { appId: string; key: string; value: string };
+}
+
 /**
  * ViewEvents - Events for the "view" namespace
  */
 export interface ViewEvents {
-  "view/bounds-updated": ViewBounds;
-  "view/global-bounds-changed": { workspaceBounds: ViewBounds; windowSize: WindowSize };
+  "view/bounds-updated": import("./index").ViewBounds;
+  "view/global-bounds-changed": {
+    workspaceBounds: import("./index").ViewBounds;
+    windowSize: import("./index").WindowSize;
+  };
+  "view/view-loaded": { viewId: number; appId: string; overlay: boolean };
+  "view/view-load-failed": {
+    viewId: number;
+    appId: string;
+    errorCode: number;
+    errorDescription: string;
+  };
+  "view/mode-changed": { mode: "floating" | "tiled"; bounds: import("./index").ViewBounds };
 }
 
 /**
  * Global event map - merge all event namespaces
  */
-export interface AppEvents extends PackageEvents, ProcessEvents, ViewEvents {}
-
-/**
- * Array of all available event names
- */
-export const APP_EVENT_NAMES = [
-  "package/installed",
-  "package/uninstalled",
-  "process/launched",
-  "process/stopped",
-  "process/error",
-  "process/exited",
-  "view/bounds-updated",
-  "view/global-bounds-changed"
-] as const;
+export interface AppEvents extends FileEvents, NotificationEvents, PackageEvents, ProcessEvents, SettingsEvents, ViewEvents {}

package/global.d.ts

@@ -1,60 +1,56 @@
 // Ambient declarations for renderer globals
 
-import type { CommandName, CommandArgs, CommandResult } from "./commands";
-import type { EventName, EventData } from "./events";
-
-export interface EdenAPI {
-  /**
-   * Execute a shell command with type-safe arguments
-   * @param command - The command name (e.g., "process/launch")
-   * @param args - Type-safe arguments for the command
-   * @returns Promise with the command result
-   * 
-   * @example
-   * ```typescript
-   * await edenAPI.shellCommand("process/launch", { 
-   *   appId: "my-app",
-   *   bounds: { x: 0, y: 0, width: 800, height: 600 }
-   * });
-   * ```
-   */
-  shellCommand<T extends CommandName>(
-    command: T,
-    args: CommandArgs<T>
-  ): Promise<CommandResult<T>>;
-  
-  /**
-   * Subscribe to a system event
-   * @param event - The event name
-   * @param callback - Callback function receiving typed event data
-   */
-  subscribe<T extends EventName>(
-    event: T,
-    callback: (data: EventData<T>) => void
-  ): Promise<void>;
-
-  /**
-   * Unsubscribe from a system event
-   */
-  unsubscribe<T extends EventName>(
-    event: T,
-    callback: (data: EventData<T>) => void
-  ): void;
-
-  /**
-   * Check if an event is supported by the system
-   */
-  isEventSupported(event: string): Promise<boolean>;
+import type { EdenAPI, AppBusAPI, AppBusConnection } from "./ipc";
+
+export interface EdenFrame {
+  // Public API
+  setTitle: (title: string) => void;
+
+  // Internal state (used by frame system)
+  _internal: {
+    appId: string;
+    injected: boolean;
+    config: {
+      mode?: "tiled" | "floating" | "both";
+      showTitle?: boolean;
+      defaultSize?: { width: number; height: number };
+      defaultPosition?: { x: number; y: number };
+      movable?: boolean;
+      resizable?: boolean;
+      minSize?: { width: number; height: number };
+      maxSize?: { width: number; height: number };
+    };
+    currentMode: "tiled" | "floating";
+    bounds: {
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+    };
+  };
 }
 
 declare global {
   interface Window {
     /**
-     * Eden API instance available only in renderer processes
+     * Eden API instance available in renderer processes
+     */
+    edenAPI: EdenAPI;
+
+    /**
+     * AppBus instance for app-to-app communication
      */
-    edenAPI?: EdenAPI;
+    appBus: AppBusAPI;
+
+    /**
+     * Get AppAPI for frontend<->backend communication
+     * Throws if connection is not available
+     */
+    getAppAPI: () => AppBusConnection;
+
+    edenFrame?: EdenFrame;
   }
 }
 
 // This export is important - it marks the file as a module
-export {};
+export {};

package/index.d.ts

@@ -6,6 +6,10 @@ export * from "./AppManifest";
 
 export * from "./global";
 
+export * from "./worker";
+
+export * from "./ipc";
+
 /**
  * App Instance Interface
  *
@@ -80,6 +84,9 @@ export type {
 // Export event types
 export * from "./events";
 
+// Export channel/appbus types
+export * from "./channels";
+
 export interface SystemInfo {
   platform: string;
   arch: string;
@@ -99,7 +106,59 @@ export interface LaunchResult {
   appId: string;
 }
 
-export interface AppStatus {
-  installed: AppManifest[];
-  running: AppInstance[];
+/**
+ * Result of opening a file
+ */
+export interface FileOpenResult {
+  success: boolean;
+  appId?: string;
+  error?: string;
+}
+
+/**
+ * Information about a file handler
+ */
+export interface FileHandlerInfo {
+  appId: string;
+  appName: string;
+  handlerName?: string;
+  icon?: string;
+}
+
+/**
+ * File or directory statistics
+ */
+export interface FileStats {
+  isFile: boolean;
+  isDirectory: boolean;
+  size: number;
+  mtime: Date;
+}
+
+/**
+ * Search result for filesystem queries
+ */
+export interface SearchResult {
+  name: string;
+  path: string;
+  type: "file" | "folder";
+}
+
+/**
+ * Notification type/variant for styling
+ */
+export type NotificationType = "info" | "success" | "warning" | "danger";
+
+/**
+ * Notification data structure
+ */
+export interface Notification {
+  id: string;
+  title: string;
+  message: string;
+  /** Timeout in ms. If 0 or omitted, notification persists until dismissed. */
+  timeout?: number;
+  createdAt: number;
+  /** Notification type for styling (default: info) */
+  type?: NotificationType;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edenapp/types",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "TypeScript type definitions for the Eden platform",
   "types": "index.d.ts",
   "author": "Dariusz Majnert",

package/worker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Worker Global Type Definitions
+ *
+ * Type definitions for the global `worker` object available in utility processes.
+ * This mirrors the frontend's `window.edenAPI` and `window.appBus` pattern.
+ */
+
+import type { EdenAPI, AppBusAPI, AppBusConnection } from "./ipc";
+
+/**
+ * Worker global - backend runtime namespace
+ * Mirrors the frontend's window.* pattern
+ */
+export interface WorkerGlobal {
+  edenAPI: EdenAPI;
+  appBus: AppBusAPI;
+  getAppAPI: () => AppBusConnection;
+}
+
+/**
+ * Backend globals (utility process)
+ * These are set by backend-preload.ts for utility processes
+ */
+declare global {
+  /**
+   * Worker namespace (backend only)
+   * Mirrors frontend's window.* pattern:
+   * - Frontend: window.edenAPI, window.appBus
+   * - Backend:  worker.edenAPI, worker.appBus
+   */
+  var worker: WorkerGlobal | undefined;
+}