@owdproject/core 3.4.0 → 4.0.0-alpha.4

package/dist/shared/core.d_A3q1kZ.mjs

@@ -0,0 +1,869 @@
+import { createActor } from 'xstate';
+import { w as windowMachine, a as applicationMachine } from './core.B3mp7ztE.mjs';
+import { c as computeSnapRect } from './core.CsDFgGnX.mjs';
+import { g as globalDesktopHooks, a as globalIPCBus } from './core.Pd_Ogt4g.mjs';
+
+function formatWindowSnapshotValue(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length > 0) {
+      const [k, v] = entries[0];
+      return `${k}.${formatWindowSnapshotValue(v)}`;
+    }
+  }
+  return "normal";
+}
+class WindowInstance {
+  id;
+  model;
+  applicationId;
+  config;
+  state;
+  meta;
+  actor;
+  isDisposed = false;
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.id = options.id;
+    this.model = options.model;
+    this.applicationId = options.applicationId;
+    this.config = { ...options.config };
+    this.meta = options.meta ? { ...options.meta } : {};
+    const baseState = {
+      id: this.id,
+      createdAt: Date.now(),
+      category: options.config.category,
+      workspace: options.initialState?.workspace ?? options.workspace ?? "workspace-1",
+      position: options.initialState?.position ? { ...options.initialState.position } : options.config.position ? { ...options.config.position } : { x: 0, y: 0, z: 0 },
+      size: options.initialState?.size ? { ...options.initialState.size } : options.config.size ? { ...options.config.size } : { width: 640, height: 480 },
+      focused: options.initialState?.focused ?? true,
+      active: options.initialState?.active ?? true,
+      maximized: options.initialState?.maximized ?? false,
+      layout: options.initialState?.layout ?? "normal",
+      draggable: options.config.draggable !== false,
+      resizable: options.config.resizable !== false,
+      minimizable: options.config.minimizable !== false,
+      maximizable: options.config.maximizable !== false,
+      destroyable: options.config.destroyable !== false,
+      ...options.initialState
+    };
+    this.state = Object.freeze(baseState);
+    let initialMachineValue = { normal: "unfocused" };
+    if (this.state.active === false) {
+      initialMachineValue = "minimized";
+    } else if (this.state.maximized === true) {
+      initialMachineValue = this.state.focused ? { maximized: "focused" } : { maximized: "unfocused" };
+    } else if (this.state.focused === true) {
+      initialMachineValue = { normal: { focused: "idle" } };
+    }
+    this.actor = createActor(windowMachine, {
+      state: windowMachine.resolveState({
+        value: initialMachineValue,
+        context: {
+          wasMaximized: !!this.state.maximized,
+          config: this.config
+        }
+      })
+    });
+    this.actor.subscribe((snapshot) => {
+      if (this.isDisposed) return;
+      const isMinimized = snapshot.matches("minimized");
+      const isMaximized = snapshot.matches("maximized");
+      const isFocused = snapshot.matches("normal.focused") || snapshot.matches("maximized.focused");
+      const isDragging = snapshot.matches("normal.focused.dragging");
+      const isResizing = snapshot.matches("normal.focused.resizing");
+      const nextActive = !isMinimized;
+      if (this.state.active !== nextActive || this.state.maximized !== isMaximized || this.state.focused !== isFocused || this.state.dragging !== isDragging || this.state.resizing !== isResizing) {
+        this.updateState({
+          active: nextActive,
+          maximized: isMaximized,
+          focused: isFocused,
+          dragging: isDragging,
+          resizing: isResizing
+        });
+      }
+    });
+    this.actor.start();
+  }
+  updateState(patch) {
+    this.state = Object.freeze({
+      ...this.state,
+      ...patch
+    });
+    this.notify();
+  }
+  getSnapshot() {
+    return this.state;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.state);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  notify() {
+    for (const sub of this.subscribers) {
+      try {
+        sub(this.state);
+      } catch {
+      }
+    }
+  }
+  get stateValue() {
+    return formatWindowSnapshotValue(this.actor.getSnapshot().value);
+  }
+  setPosition(data) {
+    this.updateState({
+      position: {
+        x: Math.round(data.x),
+        y: Math.round(data.y),
+        z: data.z !== void 0 ? data.z : this.state.position?.z ?? 0
+      }
+    });
+  }
+  setSize(data) {
+    this.updateState({
+      size: {
+        ...this.state.size,
+        width: Math.round(data.width),
+        height: Math.round(data.height)
+      }
+    });
+  }
+  setFocus(value) {
+    if (this.isDisposed) return;
+    if (value) {
+      if (!this.state.focused) {
+        this.actor.send({ type: "FOCUS" });
+      }
+    } else {
+      if (this.state.focused) {
+        this.actor.send({ type: "BLUR" });
+      }
+    }
+  }
+  minimize() {
+    if (this.isDisposed || !this.state.minimizable) return false;
+    this.actor.send({ type: "MINIMIZE" });
+    return true;
+  }
+  unminimize() {
+    if (this.isDisposed) return false;
+    this.actor.send({ type: "RESTORE" });
+    return true;
+  }
+  maximize() {
+    if (this.isDisposed || !this.state.maximizable) return false;
+    this.actor.send({ type: "MAXIMIZE" });
+    return true;
+  }
+  unmaximize() {
+    if (this.isDisposed || !this.state.maximizable) return false;
+    this.actor.send({ type: "RESTORE" });
+    return true;
+  }
+  toggleMaximize() {
+    if (this.isDisposed || !this.state.maximizable) return false;
+    if (this.state.maximized) {
+      return this.unmaximize();
+    } else {
+      return this.maximize();
+    }
+  }
+  startDrag() {
+    if (!this.isDisposed) this.actor.send({ type: "DRAG_START" });
+  }
+  stopDrag() {
+    if (!this.isDisposed) this.actor.send({ type: "DRAG_END" });
+  }
+  startResize() {
+    if (!this.isDisposed) this.actor.send({ type: "RESIZE_START" });
+  }
+  stopResize() {
+    if (!this.isDisposed) this.actor.send({ type: "RESIZE_END" });
+  }
+  setLayout(layout, workarea) {
+    if (this.isDisposed) return false;
+    if (layout === "normal") {
+      this.actor.send({ type: "RESTORE" });
+      this.clearLayout();
+      return true;
+    }
+    if (!this.state.maximizable) return false;
+    if (layout === "maximize") {
+      this.saveBoundsBeforeLayout();
+      this.actor.send({ type: "MAXIMIZE" });
+      this.updateState({ layout: "maximize", maximized: true });
+      if (workarea && workarea.width > 0 && workarea.height > 0) {
+        this.setPosition({ x: workarea.x, y: workarea.y });
+        this.setSize({ width: workarea.width, height: workarea.height });
+      }
+    } else {
+      this.actor.send({ type: "RESTORE" });
+      this.saveBoundsBeforeLayout();
+      this.updateState({ layout, maximized: false });
+      if (workarea && workarea.width > 0 && workarea.height > 0) {
+        const rect = computeSnapRect(layout, workarea);
+        this.setPosition({ x: rect.x, y: rect.y });
+        this.setSize({ width: rect.width, height: rect.height });
+      }
+    }
+    return true;
+  }
+  clearLayout() {
+    const bounds = this.state.boundsBeforeLayout;
+    const nextState = {
+      layout: "normal",
+      maximized: false,
+      boundsBeforeLayout: void 0
+    };
+    if (bounds) {
+      nextState.position = {
+        x: Math.round(bounds.x),
+        y: Math.round(bounds.y),
+        z: this.state.position?.z ?? 0
+      };
+      nextState.size = {
+        ...this.state.size,
+        width: Math.round(bounds.width),
+        height: Math.round(bounds.height)
+      };
+    }
+    this.updateState(nextState);
+    return true;
+  }
+  saveBoundsBeforeLayout() {
+    if (this.state.layout && this.state.layout !== "normal") return;
+    const pos = this.state.position ?? { x: 0, y: 0 };
+    const size = this.state.size ?? { width: 640, height: 480 };
+    const bounds = {
+      x: pos.x ?? 0,
+      y: pos.y ?? 0,
+      width: typeof size.width === "number" ? size.width : 640,
+      height: typeof size.height === "number" ? size.height : 480
+    };
+    this.updateState({ boundsBeforeLayout: bounds });
+  }
+  setWorkspace(workspaceId) {
+    this.updateState({ workspace: workspaceId });
+  }
+  get workspace() {
+    return this.state.workspace;
+  }
+  setSpatialTransform(transform) {
+    this.updateState({ spatial: { ...transform } });
+  }
+  get spatial() {
+    return this.state.spatial;
+  }
+  dispose() {
+    if (this.isDisposed) return;
+    this.isDisposed = true;
+    try {
+      this.actor.stop();
+    } catch {
+    }
+    this.subscribers.clear();
+  }
+}
+class WindowManager {
+  windows = /* @__PURE__ */ new Map();
+  snapshotCache = Object.freeze([]);
+  zIndexCounter = 100;
+  subscribers = /* @__PURE__ */ new Set();
+  hooks;
+  ipc;
+  constructor(options) {
+    this.hooks = options?.hooks ?? globalDesktopHooks;
+    this.ipc = options?.ipc ?? globalIPCBus;
+  }
+  getSnapshot() {
+    return this.snapshotCache;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.getSnapshot());
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  notify() {
+    this.snapshotCache = Object.freeze(Array.from(this.windows.values()));
+    const snapshot = this.getSnapshot();
+    for (const sub of this.subscribers) {
+      try {
+        sub(snapshot);
+      } catch {
+      }
+    }
+  }
+  get(id) {
+    return this.windows.get(id);
+  }
+  get focusedWindow() {
+    return Array.from(this.windows.values()).find((w) => w.state.focused);
+  }
+  incrementZIndex() {
+    this.zIndexCounter += 2;
+    return this.zIndexCounter;
+  }
+  addWindow(instance) {
+    this.windows.set(instance.id, instance);
+    this.focusWindow(instance.id);
+    this.notify();
+  }
+  createWindow(options) {
+    const instance = new WindowInstance(options);
+    this.addWindow(instance);
+    this.ipc.emit("window:opened", { id: instance.id, model: instance.model }, { source: "window-manager" });
+    return instance;
+  }
+  focusWindow(id) {
+    const target = this.windows.get(id);
+    if (!target) return;
+    let previousWindow;
+    for (const win of this.windows.values()) {
+      if (win.id !== id && win.state.focused) {
+        previousWindow = win;
+        win.setFocus(false);
+        void this.hooks.callHook("window:blurred", { window: win });
+      }
+    }
+    target.setPosition({
+      x: target.state.position?.x ?? 0,
+      y: target.state.position?.y ?? 0,
+      z: this.incrementZIndex()
+    });
+    target.setFocus(true);
+    void this.hooks.callHook("window:focused", { window: target, previousWindow });
+    this.notify();
+  }
+  closeWindow(id) {
+    const target = this.windows.get(id);
+    if (!target) return false;
+    target.dispose();
+    this.windows.delete(id);
+    const remaining = Array.from(this.windows.values()).filter((w) => w.state.active).sort((a, b) => (b.state.position?.z ?? 0) - (a.state.position?.z ?? 0));
+    if (remaining.length > 0) {
+      this.focusWindow(remaining[0].id);
+    }
+    this.ipc.emit("window:closed", { id }, { source: "window-manager" });
+    this.notify();
+    return true;
+  }
+  closeAllWindows() {
+    for (const win of this.windows.values()) {
+      win.dispose();
+    }
+    this.windows.clear();
+    this.notify();
+  }
+  tileWindows(mode = "horizontal", workarea, workspaceId, gap = 0) {
+    const activeWins = Array.from(this.windows.values()).filter(
+      (w) => w.state.active && (!workspaceId || w.state.workspace === workspaceId)
+    );
+    if (activeWins.length === 0 || workarea.width <= 0 || workarea.height <= 0) {
+      return 0;
+    }
+    const count = activeWins.length;
+    const safeGap = Math.max(0, Math.round(gap));
+    if (mode === "horizontal") {
+      const totalGap = safeGap * (count - 1);
+      const colWidth = Math.floor((workarea.width - totalGap) / count);
+      activeWins.forEach((win, index) => {
+        win.saveBoundsBeforeLayout();
+        win.setLayout("normal");
+        win.setPosition({
+          x: workarea.x + index * (colWidth + safeGap),
+          y: workarea.y
+        });
+        win.setSize({
+          width: index === count - 1 ? workarea.width - (count - 1) * (colWidth + safeGap) : colWidth,
+          height: workarea.height
+        });
+      });
+    } else if (mode === "vertical") {
+      const totalGap = safeGap * (count - 1);
+      const rowHeight = Math.floor((workarea.height - totalGap) / count);
+      activeWins.forEach((win, index) => {
+        win.saveBoundsBeforeLayout();
+        win.setLayout("normal");
+        win.setPosition({
+          x: workarea.x,
+          y: workarea.y + index * (rowHeight + safeGap)
+        });
+        win.setSize({
+          width: workarea.width,
+          height: index === count - 1 ? workarea.height - (count - 1) * (rowHeight + safeGap) : rowHeight
+        });
+      });
+    } else if (mode === "grid") {
+      const cols = Math.ceil(Math.sqrt(count));
+      const rows = Math.ceil(count / cols);
+      const colWidth = Math.floor((workarea.width - safeGap * (cols - 1)) / cols);
+      const rowHeight = Math.floor((workarea.height - safeGap * (rows - 1)) / rows);
+      activeWins.forEach((win, index) => {
+        const col = index % cols;
+        const row = Math.floor(index / cols);
+        win.saveBoundsBeforeLayout();
+        win.setLayout("normal");
+        win.setPosition({
+          x: workarea.x + col * (colWidth + safeGap),
+          y: workarea.y + row * (rowHeight + safeGap)
+        });
+        win.setSize({
+          width: col === cols - 1 ? workarea.width - (cols - 1) * (colWidth + safeGap) : colWidth,
+          height: row === rows - 1 ? workarea.height - (rows - 1) * (rowHeight + safeGap) : rowHeight
+        });
+      });
+    }
+    this.notify();
+    return count;
+  }
+  setSpatialTransform(windowId, transform) {
+    const win = this.windows.get(windowId);
+    if (win) {
+      win.setSpatialTransform(transform);
+      this.notify();
+    }
+  }
+}
+
+class WorkspaceManager {
+  state;
+  subscribers = /* @__PURE__ */ new Set();
+  hooks;
+  ipc;
+  constructor(options) {
+    this.hooks = options?.hooks ?? globalDesktopHooks;
+    this.ipc = options?.ipc ?? globalIPCBus;
+    this.state = Object.freeze({
+      workspaces: Object.freeze([...options?.workspaces ?? ["workspace-1", "workspace-2", "workspace-3", "workspace-4"]]),
+      active: options?.active ?? "workspace-1",
+      workarea: Object.freeze({ ...options?.workarea ?? { x: 0, y: 0, width: 0, height: 0 } })
+    });
+  }
+  updateState(patch) {
+    this.state = Object.freeze({
+      workspaces: patch.workspaces ? Object.freeze([...patch.workspaces]) : this.state.workspaces,
+      active: patch.active ?? this.state.active,
+      workarea: patch.workarea ? Object.freeze({ ...patch.workarea }) : this.state.workarea
+    });
+    this.notify();
+  }
+  getSnapshot() {
+    return this.state;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.state);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  notify() {
+    for (const sub of this.subscribers) {
+      try {
+        sub(this.state);
+      } catch {
+      }
+    }
+  }
+  get activeWorkspace() {
+    return this.state.active;
+  }
+  get workspaces() {
+    return [...this.state.workspaces];
+  }
+  get workarea() {
+    return { ...this.state.workarea };
+  }
+  async setWorkspace(workspaceId) {
+    if (!this.state.workspaces.includes(workspaceId)) {
+      return false;
+    }
+    const previous = this.state.active;
+    if (previous === workspaceId) return true;
+    const switchCtx = { from: previous, to: workspaceId, cancel: false };
+    await this.hooks.callHook("workspace:before-switch", switchCtx);
+    if (switchCtx.cancel) return false;
+    this.updateState({ active: workspaceId });
+    await this.hooks.callHook("workspace:switched", { from: previous, to: workspaceId });
+    this.ipc.emit("workspace:switched", { from: previous, to: workspaceId }, { source: "workspace-manager" });
+    return true;
+  }
+  setWorkarea(workarea) {
+    this.updateState({ workarea });
+  }
+  addWorkspace(id) {
+    if (!this.state.workspaces.includes(id)) {
+      this.updateState({ workspaces: [...this.state.workspaces, id] });
+    }
+  }
+  removeWorkspace(id) {
+    if (this.state.workspaces.length <= 1 || !this.state.workspaces.includes(id)) {
+      return false;
+    }
+    const nextWorkspaces = this.state.workspaces.filter((w) => w !== id);
+    const nextActive = this.state.active === id ? nextWorkspaces[0] : this.state.active;
+    this.updateState({ workspaces: nextWorkspaces, active: nextActive });
+    return true;
+  }
+}
+
+function formatAppSnapshotValue(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length > 0) {
+      const [k, v] = entries[0];
+      return `${k}.${formatAppSnapshotValue(v)}`;
+    }
+  }
+  return "idle";
+}
+class ApplicationInstance {
+  id;
+  config;
+  actor;
+  _pid = null;
+  _startedAt = null;
+  _windowIds = /* @__PURE__ */ new Set();
+  snapshot;
+  subscribers = /* @__PURE__ */ new Set();
+  windowManager;
+  workspaceManager;
+  hooks;
+  ipc;
+  allocatePid;
+  constructor(options) {
+    this.id = options.config.id;
+    this.config = { ...options.config };
+    this.windowManager = options.windowManager;
+    this.workspaceManager = options.workspaceManager;
+    this.hooks = options.hooks ?? globalDesktopHooks;
+    this.ipc = options.ipc ?? globalIPCBus;
+    this.allocatePid = options.allocatePid;
+    this.actor = createActor(applicationMachine, {
+      input: { id: this.id, config: this.config }
+    });
+    this.snapshot = this.computeSnapshot("idle");
+    this.actor.subscribe((stateSnapshot) => {
+      const stateVal = formatAppSnapshotValue(stateSnapshot.value);
+      if (stateVal === "terminating") {
+        this._pid = null;
+        this._startedAt = null;
+        this.actor.send({ type: "TERMINATED" });
+        return;
+      }
+      this.snapshot = this.computeSnapshot(stateVal);
+      this.notify();
+    });
+    this.actor.start();
+    this.actor.send({ type: "LAUNCH" });
+    this.actor.send({ type: "INITIALIZED" });
+  }
+  computeSnapshot(stateValue) {
+    const currentVal = stateValue ?? formatAppSnapshotValue(this.actor.getSnapshot().value);
+    return Object.freeze({
+      id: this.id,
+      title: this.config.title,
+      icon: this.config.icon,
+      category: this.config.category,
+      stateValue: currentVal,
+      pid: this._pid,
+      startedAt: this._startedAt,
+      isRunning: currentVal.startsWith("running"),
+      isSuspended: currentVal === "running.suspended",
+      windowIds: Object.freeze(Array.from(this._windowIds))
+    });
+  }
+  refreshSnapshot() {
+    this.snapshot = this.computeSnapshot();
+    this.notify();
+  }
+  notify() {
+    for (const sub of this.subscribers) {
+      try {
+        sub(this.snapshot);
+      } catch {
+      }
+    }
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.snapshot);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  get pid() {
+    return this._pid;
+  }
+  get startedAt() {
+    return this._startedAt;
+  }
+  get stateValue() {
+    return this.snapshot.stateValue;
+  }
+  get isRunning() {
+    return this.snapshot.isRunning;
+  }
+  get isSuspended() {
+    return this.snapshot.isSuspended;
+  }
+  hasPermission(permission) {
+    if (!this.config.permissions) return true;
+    return this.config.permissions.includes(permission);
+  }
+  ensureProcessStarted() {
+    if (this._pid === null) {
+      this._pid = this.allocatePid();
+      this._startedAt = Date.now();
+    }
+  }
+  reuseSingletonWindow() {
+    if (!this.config.singleton || this._windowIds.size === 0) return void 0;
+    const existingId = Array.from(this._windowIds)[0];
+    const existingWindow = this.windowManager.get(existingId);
+    if (!existingWindow) return void 0;
+    existingWindow.unminimize();
+    this.windowManager.focusWindow(existingWindow.id);
+    return existingWindow;
+  }
+  async launch(entryKey, argument) {
+    const entries = this.config.entries ?? {};
+    const resolvedKey = entryKey ?? Object.keys(entries)[0];
+    const entry = resolvedKey ? entries[resolvedKey] : void 0;
+    const launchCtx = { app: this, entryKey: resolvedKey, argument, cancel: false };
+    await this.hooks.callHook("app:before-launch", launchCtx);
+    if (launchCtx.cancel) return false;
+    this.ensureProcessStarted();
+    this.actor.send({ type: "LAUNCH" });
+    if (entry) {
+      if (typeof entry.command === "function") {
+        await entry.command(this, argument);
+      } else if (typeof entry.command === "string" && this.config.commands) {
+        const parts = entry.command.trim().split(/\s+/);
+        const cmdName = parts[0];
+        const fn = cmdName ? this.config.commands[cmdName] : void 0;
+        if (fn) {
+          await fn(this, argument ?? parts.slice(1).join(" "));
+        }
+      }
+    } else if (this.config.windows) {
+      const firstModel = Object.keys(this.config.windows)[0];
+      if (firstModel) {
+        await this.openWindow(firstModel);
+      }
+    }
+    await this.config.onLaunch?.(this);
+    this.refreshSnapshot();
+    await this.hooks.callHook("app:launched", { app: this, pid: this._pid });
+    this.ipc.emit("app:launched", { id: this.id, pid: this._pid }, { source: this.id });
+    return true;
+  }
+  async openWindow(model, meta, initialState) {
+    const windowConfig = this.config.windows?.[model] ?? {
+      title: this.config.title,
+      icon: this.config.icon,
+      category: this.config.category,
+      size: { width: 640, height: 480 }
+    };
+    const existingWindow = this.reuseSingletonWindow();
+    if (existingWindow) return existingWindow;
+    const openCtx = {
+      app: this,
+      model,
+      config: windowConfig,
+      meta,
+      cancel: false
+    };
+    await this.hooks.callHook("window:before-open", openCtx);
+    if (openCtx.cancel) return void 0;
+    const concurrentWindow = this.reuseSingletonWindow();
+    if (concurrentWindow) return concurrentWindow;
+    this.ensureProcessStarted();
+    const winId = `${this.id}-${model}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const workspace = initialState?.workspace ?? this.workspaceManager?.activeWorkspace ?? "workspace-1";
+    const instance = this.windowManager.createWindow({
+      id: winId,
+      model,
+      applicationId: this.id,
+      config: {
+        ...windowConfig,
+        title: windowConfig.title ?? this.config.title,
+        icon: windowConfig.icon ?? this.config.icon,
+        category: windowConfig.category ?? this.config.category
+      },
+      initialState,
+      meta,
+      workspace
+    });
+    this._windowIds.add(instance.id);
+    this.actor.send({ type: "OPEN_WINDOW" });
+    this.refreshSnapshot();
+    await this.hooks.callHook("window:opened", { window: instance, app: this });
+    return instance;
+  }
+  async closeWindow(windowId) {
+    const win = this.windowManager.get(windowId);
+    if (!win) return false;
+    const closeCtx = { window: win, app: this, cancel: false };
+    await this.hooks.callHook("window:before-close", closeCtx);
+    if (closeCtx.cancel) return false;
+    this._windowIds.delete(windowId);
+    this.windowManager.closeWindow(windowId);
+    this.actor.send({ type: "CLOSE_WINDOW" });
+    this.refreshSnapshot();
+    await this.hooks.callHook("window:closed", { windowId, app: this });
+    return true;
+  }
+  closeAllWindows() {
+    for (const id of Array.from(this._windowIds)) {
+      this.windowManager.closeWindow(id);
+    }
+    this._windowIds.clear();
+    this.refreshSnapshot();
+  }
+  async suspend() {
+    if (!this.isRunning || this.isSuspended) return false;
+    const ctx = { app: this, signal: "SIGSTOP", cancel: false };
+    await this.hooks.callHook("app:before-suspend", ctx);
+    if (ctx.cancel) return false;
+    for (const id of this._windowIds) {
+      this.windowManager.get(id)?.minimize();
+    }
+    this.actor.send({ type: "SIGSTOP" });
+    this.refreshSnapshot();
+    await this.hooks.callHook("app:suspended", { app: this });
+    this.ipc.emit("process:suspended", { id: this.id, pid: this._pid }, { source: "kernel" });
+    return true;
+  }
+  async resume() {
+    if (!this.isSuspended) return false;
+    const ctx = { app: this, signal: "SIGCONT", cancel: false };
+    await this.hooks.callHook("app:before-resume", ctx);
+    if (ctx.cancel) return false;
+    for (const id of this._windowIds) {
+      const win = this.windowManager.get(id);
+      if (win) {
+        win.unminimize();
+        this.windowManager.focusWindow(win.id);
+      }
+    }
+    this.actor.send({ type: "SIGCONT" });
+    this.refreshSnapshot();
+    await this.hooks.callHook("app:resumed", { app: this });
+    this.ipc.emit("process:resumed", { id: this.id, pid: this._pid }, { source: "kernel" });
+    return true;
+  }
+  async terminate(signal = "SIGTERM") {
+    const ctx = { app: this, signal, cancel: false };
+    await this.hooks.callHook("app:before-terminate", ctx);
+    if (ctx.cancel && signal !== "SIGKILL") return false;
+    const oldPid = this._pid;
+    this.closeAllWindows();
+    await this.config.onClose?.(this);
+    this._pid = null;
+    this._startedAt = null;
+    this.actor.send({ type: signal });
+    this.refreshSnapshot();
+    await this.hooks.callHook("app:terminated", {
+      id: this.id,
+      title: this.config.title,
+      pid: oldPid
+    });
+    this.ipc.emit(
+      "process:terminated",
+      { id: this.id, pid: oldPid, signal },
+      { source: "kernel", severity: signal === "SIGKILL" ? "warn" : "info" }
+    );
+    return true;
+  }
+}
+class ApplicationManager {
+  apps = /* @__PURE__ */ new Map();
+  snapshotCache = Object.freeze([]);
+  pidCounter = 1e3;
+  subscribers = /* @__PURE__ */ new Set();
+  windowManager;
+  workspaceManager;
+  hooks;
+  ipc;
+  constructor(options) {
+    this.windowManager = options.windowManager;
+    this.workspaceManager = options.workspaceManager;
+    this.hooks = options.hooks ?? globalDesktopHooks;
+    this.ipc = options.ipc ?? globalIPCBus;
+  }
+  getSnapshot() {
+    return this.snapshotCache;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.getSnapshot());
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  notify() {
+    this.snapshotCache = Object.freeze(Array.from(this.apps.values()));
+    const snapshot = this.getSnapshot();
+    for (const sub of this.subscribers) {
+      try {
+        sub(snapshot);
+      } catch {
+      }
+    }
+  }
+  register(config) {
+    const existing = this.apps.get(config.id);
+    if (existing) return existing;
+    const instance = new ApplicationInstance({
+      config,
+      windowManager: this.windowManager,
+      workspaceManager: this.workspaceManager,
+      hooks: this.hooks,
+      ipc: this.ipc,
+      allocatePid: () => {
+        this.pidCounter += Math.floor(Math.random() * 7) + 1;
+        return this.pidCounter;
+      }
+    });
+    instance.subscribe(() => {
+      this.notify();
+    });
+    this.apps.set(config.id, instance);
+    void config.onReady?.(instance);
+    void this.hooks.callHook("app:defined", { app: instance });
+    this.notify();
+    return instance;
+  }
+  get(id) {
+    return this.apps.get(id);
+  }
+  getByPid(pid) {
+    return Array.from(this.apps.values()).find((app) => app.pid === pid);
+  }
+  get runningApps() {
+    return Array.from(this.apps.values()).filter((app) => app.isRunning);
+  }
+  async launch(id, entryKey, argument) {
+    const app = this.apps.get(id);
+    if (!app) return false;
+    return app.launch(entryKey, argument);
+  }
+  async terminate(idOrPid, signal = "SIGTERM") {
+    const app = typeof idOrPid === "number" ? this.getByPid(idOrPid) : this.get(idOrPid);
+    if (!app) return false;
+    return app.terminate(signal);
+  }
+}
+
+export { ApplicationInstance as A, WindowInstance as W, ApplicationManager as a, WindowManager as b, WorkspaceManager as c };