@owdproject/core 3.4.0 → 4.0.0-alpha.3

package/dist/index.d.mts

@@ -0,0 +1,73 @@
+import { Hookable } from 'hookable';
+import { DesktopRuntimeHooks, DesktopWorkareaRect, DesktopCommand, DesktopKernelEvent } from './types/index.mjs';
+export { ApplicationConfig, ApplicationConfigProvide, ApplicationEntry, ApplicationEntryVisibility, ApplicationPermission, CommandOutput, DesktopAppDefineContext, DesktopAppLaunchContext, DesktopAppSignalContext, DesktopCommandArg, DesktopCommandExecContext, DesktopCommandOption, DesktopWindowCloseContext, DesktopWindowOpenContext, DesktopWorkspaceSwitchContext, SpatialEuler, SpatialLayoutMode, SpatialPoint3D, SpatialTransform, WindowBounds, WindowConfig, WindowLayout, WindowOverride, WindowPosition, WindowSize, WindowSizeValue, WindowState, WindowStoredState } from './types/index.mjs';
+import { C as CoreIPCBus, W as WindowManager, a as WindowInstance } from './shared/core.Di1eFcr_.mjs';
+export { E as EventHandler, g as globalIPCBus } from './shared/core.Di1eFcr_.mjs';
+import { WorkspaceManager, ApplicationManager, ApplicationInstance, WorkspaceState } from './managers/index.mjs';
+export { ApplicationProcessSnapshot } from './managers/index.mjs';
+import { DesktopCommands, DesktopKeybindings } from './events/index.mjs';
+export { DesktopCommandHandler, KeybindingActionContext, KeybindingHandler, RegisteredDesktopCommand, createDesktopHooks, formatDuration, globalDesktopHooks, padEnd, parseCommandLine, shellEscape } from './events/index.mjs';
+import { DesktopSerializedSession } from './session/index.mjs';
+export { DesktopSerializedWindow, DesktopSessionManager } from './session/index.mjs';
+export { ApplicationMachine, WindowMachine, applicationMachine, windowMachine } from './machines/index.mjs';
+export { DetectSnapZoneOptions, EMPTY_DESKTOP_WORKAREA, WINDOW_SNAP_EDGE_PX, WORKSPACE_EDGE_DROP_PX, computeCenteredPosition, computeSnapRect, detectSnapZone, parseWindowConfigSize, resolveDesktopWorkarea, resolveInitialWindowPosition, workareaBottom, workareaRight } from './layout/index.mjs';
+export { DesktopPointerSession, DragSessionOptions, IframeGuard, ResizeDirection, ResizeSessionOptions } from './dom/index.mjs';
+import 'xstate';
+
+interface DesktopOptions {
+    workspaces?: string[];
+    activeWorkspace?: string;
+    workarea?: DesktopWorkareaRect;
+    maxIpcEvents?: number;
+}
+interface DesktopSnapshot {
+    readonly windows: readonly WindowInstance[];
+    readonly applications: readonly ApplicationInstance[];
+    readonly workspace: WorkspaceState;
+    readonly commands: readonly DesktopCommand[];
+    readonly events: readonly DesktopKernelEvent[];
+}
+/**
+ * Unified, framework-independent Desktop instance.
+ * Encapsulates WindowManager, ApplicationManager, WorkspaceManager, DesktopCommands,
+ * Hookable lifecycle hooks, IPC event bus, session persistence, and service registry.
+ */
+declare class Desktop {
+    readonly hooks: Hookable<DesktopRuntimeHooks>;
+    readonly ipc: CoreIPCBus;
+    readonly windows: WindowManager;
+    readonly workspaces: WorkspaceManager;
+    readonly applications: ApplicationManager;
+    readonly commands: DesktopCommands;
+    readonly keybindings: DesktopKeybindings;
+    private serviceRegistry;
+    private snapshotCache;
+    private subscribers;
+    constructor(options?: DesktopOptions);
+    private buildSnapshot;
+    getSnapshot(): DesktopSnapshot;
+    subscribe(callback: (snapshot: DesktopSnapshot) => void): () => void;
+    readonly session: {
+        serialize: () => DesktopSerializedSession;
+        restore: (sessionData: DesktopSerializedSession, options?: {
+            componentResolver?: (model: string) => any;
+        }) => {
+            restoredCount: number;
+            errors: string[];
+        };
+    };
+    readonly services: {
+        provide: <T>(name: string, service: T) => void;
+        inject: <T = any>(name: string) => T | undefined;
+        has: (name: string) => boolean;
+    };
+}
+/**
+ * Primary factory to create an isolated, headless Desktop instance.
+ */
+declare function createDesktop(options?: DesktopOptions): Desktop;
+declare const createDesktopKernel: typeof createDesktop;
+type DesktopKernel = Desktop;
+
+export { ApplicationInstance, ApplicationManager, CoreIPCBus, Desktop, DesktopCommand, DesktopCommands, DesktopKernelEvent, DesktopKeybindings, DesktopRuntimeHooks, DesktopSerializedSession, DesktopWorkareaRect, WindowInstance, WindowManager, WorkspaceManager, WorkspaceState, createDesktop, createDesktopKernel };
+export type { DesktopKernel, DesktopOptions, DesktopSnapshot };

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import { Hookable } from 'hookable';
+import { DesktopRuntimeHooks, DesktopWorkareaRect, DesktopCommand, DesktopKernelEvent } from './types/index.js';
+export { ApplicationConfig, ApplicationConfigProvide, ApplicationEntry, ApplicationEntryVisibility, ApplicationPermission, CommandOutput, DesktopAppDefineContext, DesktopAppLaunchContext, DesktopAppSignalContext, DesktopCommandArg, DesktopCommandExecContext, DesktopCommandOption, DesktopWindowCloseContext, DesktopWindowOpenContext, DesktopWorkspaceSwitchContext, SpatialEuler, SpatialLayoutMode, SpatialPoint3D, SpatialTransform, WindowBounds, WindowConfig, WindowLayout, WindowOverride, WindowPosition, WindowSize, WindowSizeValue, WindowState, WindowStoredState } from './types/index.js';
+import { C as CoreIPCBus, W as WindowManager, a as WindowInstance } from './shared/core.BOvFdEVQ.js';
+export { E as EventHandler, g as globalIPCBus } from './shared/core.BOvFdEVQ.js';
+import { WorkspaceManager, ApplicationManager, ApplicationInstance, WorkspaceState } from './managers/index.js';
+export { ApplicationProcessSnapshot } from './managers/index.js';
+import { DesktopCommands, DesktopKeybindings } from './events/index.js';
+export { DesktopCommandHandler, KeybindingActionContext, KeybindingHandler, RegisteredDesktopCommand, createDesktopHooks, formatDuration, globalDesktopHooks, padEnd, parseCommandLine, shellEscape } from './events/index.js';
+import { DesktopSerializedSession } from './session/index.js';
+export { DesktopSerializedWindow, DesktopSessionManager } from './session/index.js';
+export { ApplicationMachine, WindowMachine, applicationMachine, windowMachine } from './machines/index.js';
+export { DetectSnapZoneOptions, EMPTY_DESKTOP_WORKAREA, WINDOW_SNAP_EDGE_PX, WORKSPACE_EDGE_DROP_PX, computeCenteredPosition, computeSnapRect, detectSnapZone, parseWindowConfigSize, resolveDesktopWorkarea, resolveInitialWindowPosition, workareaBottom, workareaRight } from './layout/index.js';
+export { DesktopPointerSession, DragSessionOptions, IframeGuard, ResizeDirection, ResizeSessionOptions } from './dom/index.js';
+import 'xstate';
+
+interface DesktopOptions {
+    workspaces?: string[];
+    activeWorkspace?: string;
+    workarea?: DesktopWorkareaRect;
+    maxIpcEvents?: number;
+}
+interface DesktopSnapshot {
+    readonly windows: readonly WindowInstance[];
+    readonly applications: readonly ApplicationInstance[];
+    readonly workspace: WorkspaceState;
+    readonly commands: readonly DesktopCommand[];
+    readonly events: readonly DesktopKernelEvent[];
+}
+/**
+ * Unified, framework-independent Desktop instance.
+ * Encapsulates WindowManager, ApplicationManager, WorkspaceManager, DesktopCommands,
+ * Hookable lifecycle hooks, IPC event bus, session persistence, and service registry.
+ */
+declare class Desktop {
+    readonly hooks: Hookable<DesktopRuntimeHooks>;
+    readonly ipc: CoreIPCBus;
+    readonly windows: WindowManager;
+    readonly workspaces: WorkspaceManager;
+    readonly applications: ApplicationManager;
+    readonly commands: DesktopCommands;
+    readonly keybindings: DesktopKeybindings;
+    private serviceRegistry;
+    private snapshotCache;
+    private subscribers;
+    constructor(options?: DesktopOptions);
+    private buildSnapshot;
+    getSnapshot(): DesktopSnapshot;
+    subscribe(callback: (snapshot: DesktopSnapshot) => void): () => void;
+    readonly session: {
+        serialize: () => DesktopSerializedSession;
+        restore: (sessionData: DesktopSerializedSession, options?: {
+            componentResolver?: (model: string) => any;
+        }) => {
+            restoredCount: number;
+            errors: string[];
+        };
+    };
+    readonly services: {
+        provide: <T>(name: string, service: T) => void;
+        inject: <T = any>(name: string) => T | undefined;
+        has: (name: string) => boolean;
+    };
+}
+/**
+ * Primary factory to create an isolated, headless Desktop instance.
+ */
+declare function createDesktop(options?: DesktopOptions): Desktop;
+declare const createDesktopKernel: typeof createDesktop;
+type DesktopKernel = Desktop;
+
+export { ApplicationInstance, ApplicationManager, CoreIPCBus, Desktop, DesktopCommand, DesktopCommands, DesktopKernelEvent, DesktopKeybindings, DesktopRuntimeHooks, DesktopSerializedSession, DesktopWorkareaRect, WindowInstance, WindowManager, WorkspaceManager, WorkspaceState, createDesktop, createDesktopKernel };
+export type { DesktopKernel, DesktopOptions, DesktopSnapshot };

package/dist/index.mjs

@@ -0,0 +1,115 @@
+import { c as WorkspaceManager, b as WindowManager, a as ApplicationManager } from './shared/core.B0B0KfVK.mjs';
+export { A as ApplicationInstance, W as WindowInstance } from './shared/core.B0B0KfVK.mjs';
+import { c as createDesktopHooks, C as CoreIPCBus } from './shared/core.Pd_Ogt4g.mjs';
+export { g as globalDesktopHooks, a as globalIPCBus } from './shared/core.Pd_Ogt4g.mjs';
+import { D as DesktopCommands, a as DesktopKeybindings } from './shared/core.B1XxB289.mjs';
+export { f as formatDuration, p as padEnd, b as parseCommandLine, s as shellEscape } from './shared/core.B1XxB289.mjs';
+import { DesktopSessionManager } from './session/index.mjs';
+export { a as applicationMachine, w as windowMachine } from './shared/core.B3mp7ztE.mjs';
+export { c as computeSnapRect, w as workareaBottom, a as workareaRight } from './shared/core.CsDFgGnX.mjs';
+export { W as WINDOW_SNAP_EDGE_PX, a as WORKSPACE_EDGE_DROP_PX, d as detectSnapZone } from './shared/core.b3Xldzyu.mjs';
+export { EMPTY_DESKTOP_WORKAREA, computeCenteredPosition, parseWindowConfigSize, resolveDesktopWorkarea, resolveInitialWindowPosition } from './layout/index.mjs';
+export { DesktopPointerSession, IframeGuard } from './dom/index.mjs';
+import 'xstate';
+import 'hookable';
+
+class Desktop {
+  hooks;
+  ipc;
+  windows;
+  workspaces;
+  applications;
+  commands;
+  keybindings;
+  serviceRegistry = /* @__PURE__ */ new Map();
+  snapshotCache;
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.hooks = createDesktopHooks();
+    this.ipc = new CoreIPCBus({ maxEvents: options?.maxIpcEvents ?? 150 });
+    this.workspaces = new WorkspaceManager({
+      workspaces: options?.workspaces,
+      active: options?.activeWorkspace,
+      workarea: options?.workarea,
+      hooks: this.hooks,
+      ipc: this.ipc
+    });
+    this.windows = new WindowManager({
+      hooks: this.hooks,
+      ipc: this.ipc
+    });
+    this.applications = new ApplicationManager({
+      windowManager: this.windows,
+      workspaceManager: this.workspaces,
+      hooks: this.hooks,
+      ipc: this.ipc
+    });
+    this.commands = new DesktopCommands({
+      hooks: this.hooks,
+      ipc: this.ipc
+    });
+    this.keybindings = new DesktopKeybindings(this.windows);
+    this.snapshotCache = this.buildSnapshot();
+    const refresh = () => {
+      this.snapshotCache = this.buildSnapshot();
+      for (const sub of this.subscribers) {
+        try {
+          sub(this.snapshotCache);
+        } catch {
+        }
+      }
+    };
+    this.windows.subscribe(refresh);
+    this.applications.subscribe(refresh);
+    this.workspaces.subscribe(refresh);
+    this.commands.subscribe(refresh);
+    this.ipc.subscribe(refresh);
+  }
+  buildSnapshot() {
+    return Object.freeze({
+      windows: this.windows.getSnapshot(),
+      applications: this.applications.getSnapshot(),
+      workspace: this.workspaces.getSnapshot(),
+      commands: this.commands.getSnapshot(),
+      events: Object.freeze([...this.ipc.getEvents()])
+    });
+  }
+  getSnapshot() {
+    return this.snapshotCache;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.snapshotCache);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  session = {
+    serialize: () => DesktopSessionManager.serialize(this.windows, {
+      activeWorkspace: this.workspaces.activeWorkspace
+    }),
+    restore: (sessionData, options) => {
+      if (sessionData.activeWorkspace) {
+        void this.workspaces.setWorkspace(sessionData.activeWorkspace);
+      }
+      return DesktopSessionManager.restore(this.windows, sessionData, options);
+    }
+  };
+  services = {
+    provide: (name, service) => {
+      this.serviceRegistry.set(name, service);
+    },
+    inject: (name) => {
+      return this.serviceRegistry.get(name);
+    },
+    has: (name) => {
+      return this.serviceRegistry.has(name);
+    }
+  };
+}
+function createDesktop(options) {
+  return new Desktop(options);
+}
+const createDesktopKernel = createDesktop;
+
+export { ApplicationManager, CoreIPCBus, Desktop, DesktopCommands, DesktopKeybindings, DesktopSessionManager, WindowManager, WorkspaceManager, createDesktop, createDesktopHooks, createDesktopKernel };

package/dist/layout/index.d.mts

@@ -0,0 +1,41 @@
+import { WindowLayout, DesktopWorkareaRect, WindowBounds, WindowConfig } from '../types/index.mjs';
+
+declare function workareaBottom(workarea: DesktopWorkareaRect): number;
+declare function workareaRight(workarea: DesktopWorkareaRect): number;
+/**
+ * Pure math: Viewport rectangle for a snap zone inside the shell work area.
+ */
+declare function computeSnapRect(zone: Exclude<WindowLayout, 'normal'>, workarea: DesktopWorkareaRect): WindowBounds;
+
+type SnapZoneHint = Exclude<WindowLayout, 'normal'>;
+declare const WINDOW_SNAP_EDGE_PX = 24;
+declare const WORKSPACE_EDGE_DROP_PX = 32;
+type DetectSnapZoneOptions = {
+    edgePx?: number;
+    /** When true, left/right half snap is suppressed in the outer workspace-edge band. */
+    deferSideSnapForWorkspaceEdge?: boolean;
+};
+/**
+ * Pure math: Resolve snap zone from pointer position and shell work area.
+ * Returns null when the pointer is not in a snap band.
+ */
+declare function detectSnapZone(clientX: number, clientY: number, workarea: DesktopWorkareaRect, options?: DetectSnapZoneOptions): SnapZoneHint | null;
+
+declare const EMPTY_DESKTOP_WORKAREA: DesktopWorkareaRect;
+declare function parseWindowConfigSize(value: number | string | undefined, fallback: number): number;
+declare function resolveDesktopWorkarea(workarea?: DesktopWorkareaRect): DesktopWorkareaRect;
+declare function computeCenteredPosition(workarea: DesktopWorkareaRect, windowWidth: number, windowHeight: number): {
+    x: number;
+    y: number;
+};
+declare function resolveInitialWindowPosition(options: {
+    windowConfig: WindowConfig;
+    workarea?: DesktopWorkareaRect;
+    cascadeOffset?: number;
+}): {
+    x: number;
+    y: number;
+};
+
+export { DesktopWorkareaRect, EMPTY_DESKTOP_WORKAREA, WINDOW_SNAP_EDGE_PX, WORKSPACE_EDGE_DROP_PX, WindowBounds, WindowLayout, computeCenteredPosition, computeSnapRect, detectSnapZone, parseWindowConfigSize, resolveDesktopWorkarea, resolveInitialWindowPosition, workareaBottom, workareaRight };
+export type { DetectSnapZoneOptions, SnapZoneHint };

package/dist/layout/index.d.ts

@@ -0,0 +1,41 @@
+import { WindowLayout, DesktopWorkareaRect, WindowBounds, WindowConfig } from '../types/index.js';
+
+declare function workareaBottom(workarea: DesktopWorkareaRect): number;
+declare function workareaRight(workarea: DesktopWorkareaRect): number;
+/**
+ * Pure math: Viewport rectangle for a snap zone inside the shell work area.
+ */
+declare function computeSnapRect(zone: Exclude<WindowLayout, 'normal'>, workarea: DesktopWorkareaRect): WindowBounds;
+
+type SnapZoneHint = Exclude<WindowLayout, 'normal'>;
+declare const WINDOW_SNAP_EDGE_PX = 24;
+declare const WORKSPACE_EDGE_DROP_PX = 32;
+type DetectSnapZoneOptions = {
+    edgePx?: number;
+    /** When true, left/right half snap is suppressed in the outer workspace-edge band. */
+    deferSideSnapForWorkspaceEdge?: boolean;
+};
+/**
+ * Pure math: Resolve snap zone from pointer position and shell work area.
+ * Returns null when the pointer is not in a snap band.
+ */
+declare function detectSnapZone(clientX: number, clientY: number, workarea: DesktopWorkareaRect, options?: DetectSnapZoneOptions): SnapZoneHint | null;
+
+declare const EMPTY_DESKTOP_WORKAREA: DesktopWorkareaRect;
+declare function parseWindowConfigSize(value: number | string | undefined, fallback: number): number;
+declare function resolveDesktopWorkarea(workarea?: DesktopWorkareaRect): DesktopWorkareaRect;
+declare function computeCenteredPosition(workarea: DesktopWorkareaRect, windowWidth: number, windowHeight: number): {
+    x: number;
+    y: number;
+};
+declare function resolveInitialWindowPosition(options: {
+    windowConfig: WindowConfig;
+    workarea?: DesktopWorkareaRect;
+    cascadeOffset?: number;
+}): {
+    x: number;
+    y: number;
+};
+
+export { DesktopWorkareaRect, EMPTY_DESKTOP_WORKAREA, WINDOW_SNAP_EDGE_PX, WORKSPACE_EDGE_DROP_PX, WindowBounds, WindowLayout, computeCenteredPosition, computeSnapRect, detectSnapZone, parseWindowConfigSize, resolveDesktopWorkarea, resolveInitialWindowPosition, workareaBottom, workareaRight };
+export type { DetectSnapZoneOptions, SnapZoneHint };

package/dist/layout/index.mjs

@@ -0,0 +1,64 @@
+export { c as computeSnapRect, w as workareaBottom, a as workareaRight } from '../shared/core.CsDFgGnX.mjs';
+export { W as WINDOW_SNAP_EDGE_PX, a as WORKSPACE_EDGE_DROP_PX, d as detectSnapZone } from '../shared/core.b3Xldzyu.mjs';
+
+const EMPTY_DESKTOP_WORKAREA = {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0
+};
+function parseWindowConfigSize(value, fallback) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    return Number(value);
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return fallback;
+}
+function resolveDesktopWorkarea(workarea = EMPTY_DESKTOP_WORKAREA) {
+  if (workarea.width > 0 && workarea.height > 0) {
+    return workarea;
+  }
+  if (typeof globalThis === "undefined" || !("innerWidth" in globalThis)) {
+    return workarea;
+  }
+  return {
+    x: 0,
+    y: 0,
+    width: globalThis.innerWidth,
+    height: globalThis.innerHeight
+  };
+}
+function computeCenteredPosition(workarea, windowWidth, windowHeight) {
+  return {
+    x: workarea.x + (workarea.width - windowWidth) / 2,
+    y: workarea.y + (workarea.height - windowHeight) / 2
+  };
+}
+function resolveInitialWindowPosition(options) {
+  const { windowConfig, cascadeOffset = 0 } = options;
+  const workarea = resolveDesktopWorkarea(options.workarea);
+  const layoutWidth = parseWindowConfigSize(windowConfig.size?.width, 400);
+  const layoutHeight = parseWindowConfigSize(windowConfig.size?.height, 240);
+  const hasExplicitPosition = windowConfig.position?.x !== void 0 || windowConfig.position?.y !== void 0;
+  if (!hasExplicitPosition) {
+    const { x, y } = computeCenteredPosition(workarea, layoutWidth, layoutHeight);
+    return { x: x + cascadeOffset, y: y + cascadeOffset };
+  }
+  const scrollY = typeof globalThis !== "undefined" && "scrollY" in globalThis ? globalThis.scrollY : 0;
+  const baseX = windowConfig.position?.x ?? 0;
+  const baseY = windowConfig.position?.y !== void 0 ? scrollY + windowConfig.position.y : scrollY;
+  return {
+    x: baseX + cascadeOffset,
+    y: baseY + cascadeOffset
+  };
+}
+
+export { EMPTY_DESKTOP_WORKAREA, computeCenteredPosition, parseWindowConfigSize, resolveDesktopWorkarea, resolveInitialWindowPosition };

package/dist/machines/index.d.mts

@@ -0,0 +1,31 @@
+import * as xstate from 'xstate';
+
+declare const windowMachine: xstate.StateMachine<({ input }: {
+    input?: {
+        config?: any;
+    };
+}) => {
+    wasMaximized: boolean;
+    config: any;
+}, xstate.AnyEventObject, Record<string, xstate.AnyActorRef>, xstate.ProvidedActor, xstate.ParameterizedObject, xstate.ParameterizedObject, string, xstate.StateValue, string, {
+    config?: any;
+} | undefined, xstate.NonReducibleUnknown, xstate.EventObject, any, any, any>;
+type WindowMachine = typeof windowMachine;
+
+declare const applicationMachine: xstate.StateMachine<({ input }: {
+    input?: {
+        id?: string;
+        config?: any;
+    };
+}) => {
+    id: string;
+    config: any;
+    windowCount: number;
+}, xstate.AnyEventObject, Record<string, xstate.AnyActorRef>, xstate.ProvidedActor, xstate.ParameterizedObject, xstate.ParameterizedObject, string, xstate.StateValue, string, {
+    id?: string;
+    config?: any;
+} | undefined, xstate.NonReducibleUnknown, xstate.EventObject, any, any, any>;
+type ApplicationMachine = typeof applicationMachine;
+
+export { applicationMachine, windowMachine };
+export type { ApplicationMachine, WindowMachine };

package/dist/machines/index.d.ts

@@ -0,0 +1,31 @@
+import * as xstate from 'xstate';
+
+declare const windowMachine: xstate.StateMachine<({ input }: {
+    input?: {
+        config?: any;
+    };
+}) => {
+    wasMaximized: boolean;
+    config: any;
+}, xstate.AnyEventObject, Record<string, xstate.AnyActorRef>, xstate.ProvidedActor, xstate.ParameterizedObject, xstate.ParameterizedObject, string, xstate.StateValue, string, {
+    config?: any;
+} | undefined, xstate.NonReducibleUnknown, xstate.EventObject, any, any, any>;
+type WindowMachine = typeof windowMachine;
+
+declare const applicationMachine: xstate.StateMachine<({ input }: {
+    input?: {
+        id?: string;
+        config?: any;
+    };
+}) => {
+    id: string;
+    config: any;
+    windowCount: number;
+}, xstate.AnyEventObject, Record<string, xstate.AnyActorRef>, xstate.ProvidedActor, xstate.ParameterizedObject, xstate.ParameterizedObject, string, xstate.StateValue, string, {
+    id?: string;
+    config?: any;
+} | undefined, xstate.NonReducibleUnknown, xstate.EventObject, any, any, any>;
+type ApplicationMachine = typeof applicationMachine;
+
+export { applicationMachine, windowMachine };
+export type { ApplicationMachine, WindowMachine };

package/dist/machines/index.mjs

@@ -0,0 +1,2 @@
+export { a as applicationMachine, w as windowMachine } from '../shared/core.B3mp7ztE.mjs';
+import 'xstate';

package/dist/managers/index.d.mts

@@ -0,0 +1,117 @@
+import { W as WindowManager, a as WindowInstance } from '../shared/core.Di1eFcr_.mjs';
+import { CoreIPCBus } from '../events/index.mjs';
+import { Hookable } from 'hookable';
+import { DesktopWorkareaRect, DesktopRuntimeHooks, ApplicationConfig, ApplicationPermission, WindowState } from '../types/index.mjs';
+
+interface WorkspaceState {
+    readonly workspaces: readonly string[];
+    readonly active: string;
+    readonly workarea: DesktopWorkareaRect;
+}
+declare class WorkspaceManager {
+    private state;
+    private subscribers;
+    private hooks;
+    private ipc;
+    constructor(options?: {
+        workspaces?: string[];
+        active?: string;
+        workarea?: DesktopWorkareaRect;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+    });
+    private updateState;
+    getSnapshot(): WorkspaceState;
+    subscribe(callback: (state: WorkspaceState) => void): () => void;
+    private notify;
+    get activeWorkspace(): string;
+    get workspaces(): string[];
+    get workarea(): DesktopWorkareaRect;
+    setWorkspace(workspaceId: string): Promise<boolean>;
+    setWorkarea(workarea: DesktopWorkareaRect): void;
+    addWorkspace(id: string): void;
+    removeWorkspace(id: string): boolean;
+}
+
+interface ApplicationProcessSnapshot {
+    readonly id: string;
+    readonly title: string;
+    readonly icon?: string;
+    readonly category?: string;
+    readonly stateValue: string;
+    readonly pid: number | null;
+    readonly startedAt: number | null;
+    readonly isRunning: boolean;
+    readonly isSuspended: boolean;
+    readonly windowIds: readonly string[];
+}
+declare class ApplicationInstance {
+    readonly id: string;
+    readonly config: ApplicationConfig;
+    private actor;
+    private _pid;
+    private _startedAt;
+    private _windowIds;
+    private snapshot;
+    private subscribers;
+    private windowManager;
+    private workspaceManager?;
+    private hooks;
+    private ipc;
+    private allocatePid;
+    constructor(options: {
+        config: ApplicationConfig;
+        windowManager: WindowManager;
+        workspaceManager?: WorkspaceManager;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+        allocatePid: () => number;
+    });
+    private computeSnapshot;
+    private refreshSnapshot;
+    private notify;
+    getSnapshot(): ApplicationProcessSnapshot;
+    subscribe(callback: (snapshot: ApplicationProcessSnapshot) => void): () => void;
+    get pid(): number | null;
+    get startedAt(): number | null;
+    get stateValue(): string;
+    get isRunning(): boolean;
+    get isSuspended(): boolean;
+    hasPermission(permission: ApplicationPermission): boolean;
+    private ensureProcessStarted;
+    launch(entryKey?: string, argument?: string): Promise<boolean>;
+    openWindow(model: string, meta?: Record<string, any>, initialState?: Partial<WindowState>): Promise<WindowInstance | undefined>;
+    closeWindow(windowId: string): Promise<boolean>;
+    closeAllWindows(): void;
+    suspend(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    terminate(signal?: 'SIGTERM' | 'SIGKILL'): Promise<boolean>;
+}
+declare class ApplicationManager {
+    private apps;
+    private snapshotCache;
+    private pidCounter;
+    private subscribers;
+    private windowManager;
+    private workspaceManager?;
+    private hooks;
+    private ipc;
+    constructor(options: {
+        windowManager: WindowManager;
+        workspaceManager?: WorkspaceManager;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+    });
+    getSnapshot(): ApplicationInstance[];
+    subscribe(callback: (apps: ApplicationInstance[]) => void): () => void;
+    private notify;
+    register(config: ApplicationConfig): ApplicationInstance;
+    get(id: string): ApplicationInstance | undefined;
+    getByPid(pid: number): ApplicationInstance | undefined;
+    get runningApps(): ApplicationInstance[];
+    launch(id: string, entryKey?: string, argument?: string): Promise<boolean>;
+    terminate(idOrPid: string | number, signal?: 'SIGTERM' | 'SIGKILL'): Promise<boolean>;
+}
+
+export { ApplicationInstance, ApplicationManager, WindowInstance, WindowManager, WorkspaceManager };
+export type { ApplicationProcessSnapshot, WorkspaceState };