@tutti-os/workspace-app-center 0.0.9 → 0.0.11

package/dist/chunk-5SANC3S6.js

@@ -0,0 +1,1857 @@
+import {
+  workspaceAppManifestSchemaVersion
+} from "./chunk-UBERYRMA.js";
+
+// src/core/appCenterControllerHelpers.ts
+function resolveAppRunDurationMs(startedAtUnixMs, now) {
+  if (typeof startedAtUnixMs !== "number" || !Number.isFinite(startedAtUnixMs) || startedAtUnixMs <= 0) {
+    return null;
+  }
+  return Math.max(0, now - startedAtUnixMs);
+}
+function sortWorkspaceAppCenterApps(apps) {
+  return [...apps].sort(
+    (left, right) => left.name.localeCompare(right.name, void 0, { sensitivity: "base" })
+  );
+}
+function mergeWorkspaceAppCatalogFields(currentApp, snapshotApp) {
+  return {
+    ...currentApp,
+    availableIconUrl: snapshotApp.availableIconUrl,
+    availableVersion: snapshotApp.availableVersion,
+    description: snapshotApp.description,
+    iconUrl: snapshotApp.iconUrl,
+    localizations: snapshotApp.localizations,
+    minimizeBehavior: snapshotApp.minimizeBehavior,
+    name: snapshotApp.name,
+    references: snapshotApp.references,
+    source: snapshotApp.source,
+    tags: snapshotApp.tags,
+    updateAvailable: snapshotApp.updateAvailable
+  };
+}
+function areWorkspaceAppCenterAppsEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((leftApp, index) => {
+    const rightApp = right[index];
+    return rightApp !== void 0 && leftApp.appId === rightApp.appId && leftApp.availableIconUrl === rightApp.availableIconUrl && leftApp.availableVersion === rightApp.availableVersion && leftApp.createdAtUnixMs === rightApp.createdAtUnixMs && leftApp.description === rightApp.description && leftApp.enabled === rightApp.enabled && leftApp.exportable === rightApp.exportable && leftApp.iconUrl === rightApp.iconUrl && leftApp.installed === rightApp.installed && leftApp.installationId === rightApp.installationId && areWorkspaceAppCenterLocalizationsEqual(
+      leftApp.localizations ?? [],
+      rightApp.localizations ?? []
+    ) && leftApp.minimizeBehavior === rightApp.minimizeBehavior && leftApp.name === rightApp.name && leftApp.references.searchSupported === rightApp.references.searchSupported && leftApp.runtimeId === rightApp.runtimeId && leftApp.runtimeStatus === rightApp.runtimeStatus && leftApp.source === rightApp.source && leftApp.stateRevision === rightApp.stateRevision && areStringArraysEqual(leftApp.tags ?? [], rightApp.tags ?? []) && (leftApp.updateAvailable ?? false) === (rightApp.updateAvailable ?? false) && leftApp.launchUrl === rightApp.launchUrl && leftApp.version === rightApp.version && leftApp.windowMinHeight === rightApp.windowMinHeight && leftApp.windowMinWidth === rightApp.windowMinWidth;
+  });
+}
+function normalizeWorkspaceAppCenterViewState(value) {
+  return {
+    activeAppTab: value?.activeAppTab === "my" ? "my" : "recommended"
+  };
+}
+function areWorkspaceAppCenterViewStatesEqual(left, right) {
+  return left.activeAppTab === right.activeAppTab;
+}
+function areWorkspaceAppCenterLocalizationsEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((leftLocalization, index) => {
+    const rightLocalization = right[index];
+    return rightLocalization !== void 0 && leftLocalization.locale === rightLocalization.locale && leftLocalization.name === rightLocalization.name && leftLocalization.description === rightLocalization.description && areStringArraysEqual(leftLocalization.tags, rightLocalization.tags);
+  });
+}
+function areStringArraysEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((value, index) => value === right[index]);
+}
+function appRuntimeKey(workspaceId, appId) {
+  return `${workspaceId}\0${appId}`;
+}
+function factoryJobKey(workspaceId, jobId) {
+  return `${workspaceId}\0${jobId}`;
+}
+function removedOrUninstalledAppIds(previousApps, nextApps) {
+  const nextAppsById = new Map(nextApps.map((app) => [app.appId, app]));
+  const appIds = [];
+  for (const previousApp of previousApps) {
+    if (!previousApp.installed) {
+      continue;
+    }
+    const nextApp = nextAppsById.get(previousApp.appId);
+    if (!nextApp?.installed) {
+      appIds.push(previousApp.appId);
+    }
+  }
+  return appIds;
+}
+function sortWorkspaceAppFactoryJobs(jobs) {
+  return [...jobs].sort(
+    (left, right) => right.updatedAtUnixMs - left.updatedAtUnixMs
+  );
+}
+function areWorkspaceAppFactoryJobsEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((leftJob, index) => {
+    const rightJob = right[index];
+    return rightJob !== void 0 && leftJob.agentSessionId === rightJob.agentSessionId && leftJob.appId === rightJob.appId && leftJob.createdAtUnixMs === rightJob.createdAtUnixMs && leftJob.description === rightJob.description && leftJob.displayName === rightJob.displayName && leftJob.failureReason === rightJob.failureReason && leftJob.jobId === rightJob.jobId && leftJob.model === rightJob.model && leftJob.prompt === rightJob.prompt && leftJob.provider === rightJob.provider && leftJob.publishedVersion === rightJob.publishedVersion && leftJob.reasoningEffort === rightJob.reasoningEffort && leftJob.status === rightJob.status && leftJob.updatedAtUnixMs === rightJob.updatedAtUnixMs && leftJob.workspaceId === rightJob.workspaceId;
+  });
+}
+function noop() {
+}
+
+// src/core/appCenterControllerTypes.ts
+var defaultCatalogLoadingRefreshDelayMs = 750;
+var defaultAppOpenLaunchWaitTimeoutMs = 35e3;
+var defaultInstallRefreshDelayMs = 750;
+function createWorkspaceAppCenterStoreState() {
+  return {
+    apps: [],
+    catalogLastError: null,
+    catalogStatus: "disabled",
+    catalogUpdatedAtUnixMs: null,
+    error: null,
+    factoryJobs: [],
+    loadStatus: "idle",
+    openingFolderAppId: null,
+    revision: 0,
+    viewStateByWorkspaceId: {},
+    workspaceId: null
+  };
+}
+
+// src/core/appCenterControllerBase.ts
+var WorkspaceAppCenterControllerBase = class {
+  store;
+  dependencies;
+  listeners = /* @__PURE__ */ new Set();
+  catalogRefreshTimer = null;
+  installRefreshTimers = /* @__PURE__ */ new Map();
+  pendingFactoryPublishKeys = /* @__PURE__ */ new Set();
+  pendingInstallKeys = /* @__PURE__ */ new Set();
+  pendingInstallReportKeys = /* @__PURE__ */ new Set();
+  appLoadSequence = 0;
+  factoryLoadSequence = 0;
+  pollingWorkspaceId = null;
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+    this.store = dependencies.store ?? createWorkspaceAppCenterStoreState();
+  }
+  get readableStore() {
+    return this.store;
+  }
+  consumeError() {
+    const error = this.store.error;
+    if (error === null) {
+      return null;
+    }
+    this.store.error = null;
+    this.bumpRevision();
+    return error;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  beginWorkspacePolling(workspaceId) {
+    const normalizedWorkspaceId = workspaceId.trim();
+    if (!normalizedWorkspaceId) {
+      return;
+    }
+    if (this.pollingWorkspaceId === normalizedWorkspaceId) {
+      return;
+    }
+    this.clearCatalogRefreshTimer();
+    this.clearInstallRefreshTimers();
+    this.pollingWorkspaceId = normalizedWorkspaceId;
+  }
+  endWorkspacePolling(workspaceId) {
+    if (this.pollingWorkspaceId !== workspaceId.trim()) {
+      return;
+    }
+    this.pollingWorkspaceId = null;
+    this.clearCatalogRefreshTimer();
+    this.clearInstallRefreshTimers();
+  }
+  getViewState(workspaceId, restoredState) {
+    const normalizedWorkspaceId = workspaceId.trim();
+    if (!normalizedWorkspaceId) {
+      return normalizeWorkspaceAppCenterViewState(restoredState);
+    }
+    const existing = this.store.viewStateByWorkspaceId[normalizedWorkspaceId];
+    if (existing) {
+      return existing;
+    }
+    const nextState = normalizeWorkspaceAppCenterViewState(restoredState);
+    this.store.viewStateByWorkspaceId = {
+      ...this.store.viewStateByWorkspaceId,
+      [normalizedWorkspaceId]: nextState
+    };
+    return nextState;
+  }
+  setViewState(input) {
+    const normalizedWorkspaceId = input.workspaceId.trim();
+    if (!normalizedWorkspaceId) {
+      return;
+    }
+    const previous = this.getViewState(normalizedWorkspaceId);
+    const nextState = normalizeWorkspaceAppCenterViewState({
+      ...previous,
+      ...input.state
+    });
+    if (areWorkspaceAppCenterViewStatesEqual(previous, nextState)) {
+      return;
+    }
+    this.store.viewStateByWorkspaceId = {
+      ...this.store.viewStateByWorkspaceId,
+      [normalizedWorkspaceId]: nextState
+    };
+    this.bumpRevision();
+  }
+  setOperationError(error, details) {
+    const message = this.dependencies.formatError(error, details);
+    this.recordOperationFailure(error, message, details);
+    this.store.error = message;
+    this.bumpRevision();
+  }
+  setUnavailableError(error, details) {
+    const message = this.dependencies.formatError(error, details);
+    this.recordOperationFailure(error, message, details);
+    this.store.error = message;
+    this.store.loadStatus = "unavailable";
+    this.bumpRevision();
+  }
+  clearCatalogRefreshTimer() {
+    if (!this.catalogRefreshTimer) {
+      return;
+    }
+    clearTimeout(this.catalogRefreshTimer);
+    this.catalogRefreshTimer = null;
+  }
+  clearInstallRefreshTimer(workspaceId, appId) {
+    const key = appRuntimeKey(workspaceId, appId);
+    const timer = this.installRefreshTimers.get(key);
+    if (!timer) {
+      return;
+    }
+    clearTimeout(timer);
+    this.installRefreshTimers.delete(key);
+  }
+  clearInstallRefreshTimers() {
+    for (const timer of this.installRefreshTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.installRefreshTimers.clear();
+    this.pendingInstallKeys.clear();
+    this.pendingInstallReportKeys.clear();
+  }
+  recordOperationFailure(error, toastMessage, details) {
+    this.dependencies.hooks?.onOperationFailure?.({
+      details,
+      error,
+      toastMessage
+    });
+  }
+  bumpRevision() {
+    this.store.revision += 1;
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+  closeWorkspaceAppViews(workspaceId, appIds) {
+    if (appIds.length === 0) {
+      return;
+    }
+    this.dependencies.hooks?.onCloseWorkspaceAppViews?.({
+      appIds,
+      workspaceId
+    });
+  }
+  getErrorReason(error) {
+    return this.dependencies.getErrorReason?.(error) ?? null;
+  }
+};
+
+// src/core/appCenterControllerState.ts
+var WorkspaceAppCenterControllerState = class extends WorkspaceAppCenterControllerBase {
+  applySnapshot(workspaceId, snapshot) {
+    const nextApps = sortWorkspaceAppCenterApps(
+      this.mergeSnapshotAppsByStateRevision(
+        workspaceId,
+        this.withPendingInstallState(workspaceId, snapshot.apps)
+      )
+    );
+    for (const app of nextApps) {
+      this.settlePendingInstallReport({
+        app,
+        failureReason: app.failureReason ?? app.lastError ?? null,
+        workspaceId
+      });
+    }
+    const appIdsToClose = this.store.workspaceId === workspaceId ? removedOrUninstalledAppIds(this.store.apps, nextApps) : [];
+    this.scheduleCatalogLoadingRefresh(workspaceId, snapshot);
+    const changed = this.store.workspaceId !== workspaceId || this.store.catalogLastError !== (snapshot.catalogLastError ?? null) || this.store.catalogStatus !== snapshot.catalogStatus || this.store.catalogUpdatedAtUnixMs !== (snapshot.catalogUpdatedAtUnixMs ?? null) || this.store.error !== null || this.store.loadStatus !== "ready" || !areWorkspaceAppCenterAppsEqual(this.store.apps, nextApps);
+    if (!changed) {
+      return;
+    }
+    this.store.apps = nextApps;
+    this.store.catalogLastError = snapshot.catalogLastError ?? null;
+    this.store.catalogStatus = snapshot.catalogStatus;
+    this.store.catalogUpdatedAtUnixMs = snapshot.catalogUpdatedAtUnixMs ?? null;
+    this.store.error = null;
+    this.store.loadStatus = "ready";
+    this.store.workspaceId = workspaceId;
+    this.bumpRevision();
+    this.closeWorkspaceAppViews(workspaceId, appIdsToClose);
+  }
+  applyFactorySnapshot(workspaceId, snapshot) {
+    if (this.store.workspaceId !== workspaceId) {
+      this.store.workspaceId = workspaceId;
+    }
+    const nextJobs = sortWorkspaceAppFactoryJobs(snapshot.jobs);
+    if (areWorkspaceAppFactoryJobsEqual(this.store.factoryJobs, nextJobs)) {
+      return;
+    }
+    const previousJobs = this.store.factoryJobs;
+    this.store.factoryJobs = nextJobs;
+    this.dependencies.hooks?.onFactorySnapshotApplied?.({
+      nextJobs,
+      previousJobs,
+      workspaceId
+    });
+    this.bumpRevision();
+  }
+  applyAppUpdate(input) {
+    if (this.store.workspaceId !== input.workspaceId) {
+      return;
+    }
+    const currentApp = this.store.apps.find(
+      (candidate) => candidate.appId === input.app.appId
+    );
+    if (!currentApp) {
+      return;
+    }
+    const acceptedRuntimeTransition = input.app.stateRevision > currentApp.stateRevision;
+    if (acceptedRuntimeTransition && input.app.runtimeStatus === "failed" && currentApp.runtimeStatus !== "failed") {
+      this.dependencies.hooks?.onAppRuntimeFailed?.({
+        app: input.app,
+        failureReason: input.failureReason ?? null
+      });
+    }
+    if (acceptedRuntimeTransition && currentApp.runtimeStatus === "running" && input.app.runtimeStatus !== "running") {
+      this.dependencies.hooks?.onAppStopped?.({
+        app: currentApp,
+        runDurationMs: resolveAppRunDurationMs(
+          input.startedAtUnixMs,
+          this.dependencies.now?.() ?? Date.now()
+        )
+      });
+    }
+    this.applyAppSnapshot(input.workspaceId, input.app, {
+      installFailureReason: input.failureReason ?? null
+    });
+  }
+  applyAppSnapshot(workspaceId, nextApp, options = {}) {
+    if (this.store.workspaceId !== workspaceId) {
+      return;
+    }
+    const currentApp = this.store.apps.find(
+      (candidate) => candidate.appId === nextApp.appId
+    );
+    if (currentApp && nextApp.stateRevision <= currentApp.stateRevision) {
+      this.settlePendingInstallReport({
+        app: currentApp,
+        failureReason: options.installFailureReason ?? currentApp.failureReason ?? currentApp.lastError ?? null,
+        workspaceId
+      });
+      return;
+    }
+    const appIdsToClose = currentApp?.installed === true && !nextApp.installed ? [nextApp.appId] : [];
+    const nextApps = sortWorkspaceAppCenterApps([
+      ...this.store.apps.filter(
+        (candidate) => candidate.appId !== nextApp.appId
+      ),
+      nextApp
+    ]);
+    if (areWorkspaceAppCenterAppsEqual(this.store.apps, nextApps)) {
+      return;
+    }
+    this.store.apps = nextApps;
+    this.store.error = null;
+    this.store.loadStatus = "ready";
+    this.bumpRevision();
+    this.settlePendingInstallReport({
+      app: nextApp,
+      failureReason: options.installFailureReason ?? nextApp.failureReason ?? nextApp.lastError ?? null,
+      workspaceId
+    });
+    this.closeWorkspaceAppViews(workspaceId, appIdsToClose);
+  }
+  applyFactoryJobUpdate(workspaceId, job) {
+    if (this.store.workspaceId !== workspaceId) {
+      return;
+    }
+    const currentJob = this.store.factoryJobs.find(
+      (candidate) => candidate.jobId === job.jobId
+    );
+    if (currentJob && job.updatedAtUnixMs < currentJob.updatedAtUnixMs) {
+      return;
+    }
+    const nextJobs = sortWorkspaceAppFactoryJobs([
+      ...this.store.factoryJobs.filter(
+        (candidate) => candidate.jobId !== job.jobId
+      ),
+      job
+    ]);
+    if (areWorkspaceAppFactoryJobsEqual(this.store.factoryJobs, nextJobs)) {
+      return;
+    }
+    this.store.factoryJobs = nextJobs;
+    this.bumpRevision();
+  }
+  scheduleInstallRefresh(workspaceId, appId) {
+    const key = appRuntimeKey(workspaceId, appId);
+    if (this.installRefreshTimers.has(key)) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.installRefreshTimers.delete(key);
+      if (!this.pendingInstallKeys.has(key)) {
+        return;
+      }
+      void this.refreshInstallState(workspaceId, appId);
+    }, this.dependencies.installRefreshDelayMs ?? defaultInstallRefreshDelayMs);
+    this.installRefreshTimers.set(key, timer);
+  }
+  markAppStarting(appId) {
+    this.store.apps = this.store.apps.map(
+      (app) => app.appId === appId ? {
+        ...app,
+        enabled: true,
+        installed: true,
+        runtimeStatus: "preparing"
+      } : app
+    );
+    this.bumpRevision();
+  }
+  markLaunchWaitTimedOut(input) {
+    if (this.store.workspaceId !== input.workspaceId) {
+      return;
+    }
+    let changed = false;
+    this.store.apps = this.store.apps.map((app) => {
+      if (app.appId !== input.appId || !app.installed || app.runtimeStatus !== "preparing" && app.runtimeStatus !== "starting") {
+        return app;
+      }
+      changed = true;
+      return {
+        ...app,
+        runtimeStatus: "failed"
+      };
+    });
+    if (changed) {
+      this.bumpRevision();
+    }
+  }
+  resolveLaunchableApp(input) {
+    if (this.store.workspaceId !== input.workspaceId) {
+      return null;
+    }
+    const app = this.store.apps.find(
+      (candidate) => candidate.appId === input.appId
+    );
+    return app?.installed && app.runtimeStatus === "running" && app.launchUrl ? app : null;
+  }
+  markAppInstalling(appId, options = {}) {
+    this.store.apps = this.store.apps.map(
+      (app) => app.appId === appId ? {
+        ...app,
+        availableVersion: null,
+        enabled: true,
+        installed: options.preserveInstalled === true ? app.installed : false,
+        runtimeStatus: "installing",
+        updateAvailable: false
+      } : app
+    );
+    this.bumpRevision();
+  }
+  markEnabledAppsStarting() {
+    let changed = false;
+    this.store.apps = this.store.apps.map((app) => {
+      if (!app.enabled || !app.installed || app.runtimeStatus !== "idle") {
+        return app;
+      }
+      changed = true;
+      return {
+        ...app,
+        runtimeStatus: "preparing"
+      };
+    });
+    if (changed) {
+      this.bumpRevision();
+    }
+  }
+  isPendingInstallSettled(installKey, app) {
+    if (app.runtimeStatus === "failed") {
+      return true;
+    }
+    if (this.pendingInstallReportKeys.has(installKey)) {
+      return app.installed;
+    }
+    return app.installed && !app.updateAvailable && !app.availableVersion;
+  }
+  mergeSnapshotAppsByStateRevision(workspaceId, snapshotApps) {
+    if (this.store.workspaceId !== workspaceId) {
+      return [...snapshotApps];
+    }
+    const currentAppsById = new Map(
+      this.store.apps.map((app) => [app.appId, app])
+    );
+    return snapshotApps.map((snapshotApp) => {
+      const currentApp = currentAppsById.get(snapshotApp.appId);
+      if (!currentApp || currentApp.stateRevision < snapshotApp.stateRevision) {
+        return snapshotApp;
+      }
+      const installKey = appRuntimeKey(workspaceId, snapshotApp.appId);
+      if (this.pendingInstallKeys.has(installKey)) {
+        const pendingSettled = this.isPendingInstallSettled(
+          installKey,
+          snapshotApp
+        );
+        if (pendingSettled && currentApp.stateRevision <= snapshotApp.stateRevision) {
+          return snapshotApp;
+        }
+      }
+      return mergeWorkspaceAppCatalogFields(currentApp, snapshotApp);
+    });
+  }
+  scheduleCatalogLoadingRefresh(workspaceId, snapshot) {
+    if (snapshot.catalogStatus !== "loading") {
+      this.clearCatalogRefreshTimer();
+      return;
+    }
+    if (this.pollingWorkspaceId !== workspaceId || this.catalogRefreshTimer !== null) {
+      return;
+    }
+    this.catalogRefreshTimer = setTimeout(() => {
+      this.catalogRefreshTimer = null;
+      if (this.pollingWorkspaceId !== workspaceId) {
+        return;
+      }
+      void this.refresh(workspaceId);
+    }, this.dependencies.catalogLoadingRefreshDelayMs ?? defaultCatalogLoadingRefreshDelayMs);
+  }
+  withPendingInstallState(workspaceId, apps) {
+    return apps.map((app) => {
+      const installKey = appRuntimeKey(workspaceId, app.appId);
+      if (!this.pendingInstallKeys.has(installKey)) {
+        return app;
+      }
+      if (this.isPendingInstallSettled(installKey, app)) {
+        return app;
+      }
+      return {
+        ...app,
+        enabled: true,
+        installed: this.pendingInstallReportKeys.has(installKey) ? false : app.installed,
+        runtimeStatus: "installing"
+      };
+    });
+  }
+  async refreshInstallState(workspaceId, appId) {
+    try {
+      const snapshot = await this.dependencies.gateway.listWorkspaceApps(workspaceId);
+      this.applySnapshot(workspaceId, snapshot);
+    } catch (error) {
+      this.setOperationError(error, {
+        appId,
+        operation: "workspace_app.refresh_install_state",
+        uiAction: "refresh_install_state",
+        workspaceId
+      });
+    }
+    if (this.pendingInstallKeys.has(appRuntimeKey(workspaceId, appId))) {
+      this.scheduleInstallRefresh(workspaceId, appId);
+    }
+  }
+  settlePendingInstallReport(input) {
+    const installKey = appRuntimeKey(input.workspaceId, input.app.appId);
+    if (!this.pendingInstallKeys.has(installKey)) {
+      return;
+    }
+    if (!this.isPendingInstallSettled(installKey, input.app)) {
+      return;
+    }
+    this.pendingInstallKeys.delete(installKey);
+    this.clearInstallRefreshTimer(input.workspaceId, input.app.appId);
+    if (!this.pendingInstallReportKeys.delete(installKey)) {
+      return;
+    }
+    if (input.app.installed) {
+      this.dependencies.hooks?.onAppInstalled?.(input.app);
+      return;
+    }
+    this.dependencies.hooks?.onAppInstallFailed?.({
+      app: input.app,
+      appId: input.app.appId,
+      failureReason: input.failureReason ?? input.app.failureReason ?? input.app.lastError ?? null
+    });
+  }
+};
+
+// src/core/appCenterController.ts
+function createWorkspaceAppCenterController(dependencies) {
+  return new WorkspaceAppCenterController(dependencies);
+}
+var WorkspaceAppCenterController = class extends WorkspaceAppCenterControllerState {
+  async installApp(input) {
+    const installKey = appRuntimeKey(input.workspaceId, input.appId);
+    if (this.pendingInstallKeys.has(installKey)) {
+      return;
+    }
+    const previousApps = this.store.apps;
+    const appBeforeInstall = previousApps.find((app) => app.appId === input.appId) ?? null;
+    this.pendingInstallKeys.add(installKey);
+    this.pendingInstallReportKeys.add(installKey);
+    this.markAppInstalling(input.appId);
+    try {
+      const snapshot = await this.dependencies.gateway.installWorkspaceApp(
+        input.workspaceId,
+        input.appId
+      );
+      this.applySnapshot(input.workspaceId, snapshot);
+      if (this.pendingInstallKeys.has(installKey)) {
+        this.scheduleInstallRefresh(input.workspaceId, input.appId);
+      }
+    } catch (error) {
+      this.pendingInstallKeys.delete(installKey);
+      this.pendingInstallReportKeys.delete(installKey);
+      this.clearInstallRefreshTimer(input.workspaceId, input.appId);
+      this.store.apps = previousApps;
+      this.dependencies.hooks?.onAppInstallFailed?.({
+        app: appBeforeInstall,
+        appId: input.appId,
+        failureReason: this.getErrorReason(error)
+      });
+      this.setOperationError(error, {
+        appId: input.appId,
+        operation: "workspace_app.install",
+        uiAction: "install_app",
+        workspaceId: input.workspaceId
+      });
+    }
+  }
+  async prepareAppLaunch(input) {
+    const app = this.store.apps.find(
+      (candidate) => candidate.appId === input.appId
+    );
+    if (this.store.workspaceId !== input.workspaceId || !app?.installed) {
+      return null;
+    }
+    const currentLaunchableApp = this.resolveLaunchableApp(input);
+    if (currentLaunchableApp) {
+      return currentLaunchableApp;
+    }
+    const previousApps = this.store.apps;
+    this.markAppStarting(input.appId);
+    try {
+      const snapshot = await this.dependencies.gateway.launchWorkspaceApp(
+        input.workspaceId,
+        input.appId
+      );
+      this.applySnapshot(input.workspaceId, snapshot);
+    } catch (error) {
+      if (this.store.workspaceId === input.workspaceId) {
+        this.store.apps = previousApps;
+      }
+      this.setOperationError(error, {
+        appId: input.appId,
+        operation: "workspace_app.prepare_launch",
+        uiAction: "open_app",
+        workspaceId: input.workspaceId
+      });
+      return null;
+    }
+    return await this.waitForLaunchableApp(input);
+  }
+  async createFactoryJob(input) {
+    const previousJobIds = new Set(
+      this.store.factoryJobs.map((job) => job.jobId)
+    );
+    const snapshot = await this.dependencies.gateway.createWorkspaceAppFactoryJob(
+      input.workspaceId,
+      {
+        displayName: input.displayName,
+        ...input.model?.trim() ? { model: input.model.trim() } : {},
+        ...input.permissionModeId?.trim() ? { permissionModeId: input.permissionModeId.trim() } : {},
+        ...input.provider?.trim() ? { provider: input.provider.trim() } : {},
+        prompt: input.prompt,
+        ...input.reasoningEffort?.trim() ? { reasoningEffort: input.reasoningEffort.trim() } : {}
+      }
+    );
+    this.applyFactorySnapshot(input.workspaceId, snapshot);
+    this.dependencies.hooks?.onFactoryJobCreated?.(
+      snapshot.jobs.find((job) => !previousJobIds.has(job.jobId)) ?? null
+    );
+  }
+  async cancelFactoryJob(input) {
+    const snapshot = await this.dependencies.gateway.cancelWorkspaceAppFactoryJob(
+      input.workspaceId,
+      input.jobId
+    );
+    this.applyFactorySnapshot(input.workspaceId, snapshot);
+  }
+  async deleteFactoryJob(input) {
+    const snapshot = await this.dependencies.gateway.deleteWorkspaceAppFactoryJob(
+      input.workspaceId,
+      input.jobId
+    );
+    this.applyFactorySnapshot(input.workspaceId, snapshot);
+  }
+  async deleteApp(input) {
+    const app = this.store.apps.find(
+      (candidate) => candidate.appId === input.appId
+    );
+    try {
+      const snapshot = await this.dependencies.gateway.deleteWorkspaceApp(
+        input.workspaceId,
+        input.appId
+      );
+      this.pendingInstallKeys.delete(
+        appRuntimeKey(input.workspaceId, input.appId)
+      );
+      this.pendingInstallReportKeys.delete(
+        appRuntimeKey(input.workspaceId, input.appId)
+      );
+      this.clearInstallRefreshTimer(input.workspaceId, input.appId);
+      this.applySnapshot(input.workspaceId, snapshot);
+      this.dependencies.hooks?.onAppDeleted?.(app ?? null);
+    } catch (error) {
+      this.setOperationError(error, {
+        appId: input.appId,
+        operation: "workspace_app.delete",
+        uiAction: "delete_app",
+        workspaceId: input.workspaceId
+      });
+    }
+  }
+  async retryFactoryValidation(input) {
+    const snapshot = await this.dependencies.gateway.retryWorkspaceAppFactoryJobValidation(
+      input.workspaceId,
+      input.jobId
+    );
+    this.applyFactorySnapshot(input.workspaceId, snapshot);
+  }
+  async fixFactoryJob(input) {
+    const snapshot = await this.dependencies.gateway.fixWorkspaceAppFactoryJob(
+      input.workspaceId,
+      input.jobId,
+      { prompt: input.prompt }
+    );
+    this.applyFactorySnapshot(input.workspaceId, snapshot);
+  }
+  async prepareFactoryJobModification(input) {
+    try {
+      const snapshot = await this.dependencies.gateway.prepareWorkspaceAppFactoryJobModification(
+        input.workspaceId,
+        input.jobId
+      );
+      this.applyFactorySnapshot(input.workspaceId, snapshot);
+      return snapshot.jobs.find((candidate) => candidate.jobId === input.jobId) ?? null;
+    } catch (error) {
+      this.setOperationError(error, {
+        jobId: input.jobId,
+        operation: "app_factory.prepare_modification",
+        uiAction: "prepare_factory_job_modification",
+        workspaceId: input.workspaceId
+      });
+      return null;
+    }
+  }
+  async publishFactoryJob(input) {
+    const publishKey = factoryJobKey(input.workspaceId, input.jobId);
+    if (this.pendingFactoryPublishKeys.has(publishKey)) {
+      return null;
+    }
+    this.pendingFactoryPublishKeys.add(publishKey);
+    let result;
+    try {
+      result = await this.dependencies.gateway.publishWorkspaceAppFactoryJob(
+        input.workspaceId,
+        input.jobId
+      );
+    } catch (error) {
+      if (this.pendingFactoryPublishKeys.delete(publishKey)) {
+        this.setOperationError(error, {
+          jobId: input.jobId,
+          operation: "app_factory.publish",
+          uiAction: "publish_factory_job",
+          workspaceId: input.workspaceId
+        });
+      }
+      return null;
+    }
+    this.pendingFactoryPublishKeys.delete(publishKey);
+    this.applyFactorySnapshot(input.workspaceId, result.factorySnapshot);
+    this.applySnapshot(input.workspaceId, result.appSnapshot);
+    return result.factorySnapshot.jobs.find(
+      (candidate) => candidate.jobId === input.jobId
+    ) ?? null;
+  }
+  async refresh(workspaceId) {
+    const normalizedWorkspaceId = workspaceId.trim();
+    if (!normalizedWorkspaceId) {
+      return;
+    }
+    const appSequence = ++this.appLoadSequence;
+    const factorySequence = ++this.factoryLoadSequence;
+    const wasIdle = this.store.loadStatus === "idle";
+    this.store.workspaceId = normalizedWorkspaceId;
+    this.store.error = null;
+    if (wasIdle) {
+      this.store.loadStatus = "loading";
+    }
+    try {
+      const [appResult, factoryResult] = await Promise.allSettled([
+        this.dependencies.gateway.listWorkspaceApps(normalizedWorkspaceId),
+        this.dependencies.gateway.listWorkspaceAppFactoryJobs(
+          normalizedWorkspaceId
+        )
+      ]);
+      if (appResult.status === "fulfilled" && appSequence !== this.appLoadSequence) {
+        this.dependencies.hooks?.onRefreshDiscard?.({
+          currentSequence: this.appLoadSequence,
+          itemCount: appResult.value.apps.length,
+          operation: "app_center.refresh",
+          sequence: appSequence,
+          snapshotKind: "apps",
+          workspaceId: normalizedWorkspaceId
+        });
+      }
+      if (factoryResult.status === "fulfilled" && factorySequence !== this.factoryLoadSequence) {
+        this.dependencies.hooks?.onRefreshDiscard?.({
+          currentSequence: this.factoryLoadSequence,
+          itemCount: factoryResult.value.jobs.length,
+          operation: "app_center.refresh",
+          sequence: factorySequence,
+          snapshotKind: "factory_jobs",
+          workspaceId: normalizedWorkspaceId
+        });
+      }
+      let error = null;
+      if (appResult.status === "rejected" && appSequence === this.appLoadSequence) {
+        error = appResult.reason;
+      } else if (factoryResult.status === "rejected" && factorySequence === this.factoryLoadSequence) {
+        error = factoryResult.reason;
+      }
+      if (error) {
+        this.setUnavailableError(error, {
+          operation: "app_center.refresh",
+          workspaceId: normalizedWorkspaceId
+        });
+        return;
+      }
+      if (appResult.status === "fulfilled" && appSequence === this.appLoadSequence) {
+        this.applySnapshot(normalizedWorkspaceId, appResult.value);
+      }
+      if (factoryResult.status === "fulfilled" && factorySequence === this.factoryLoadSequence) {
+        this.applyFactorySnapshot(normalizedWorkspaceId, factoryResult.value);
+      }
+    } catch (error) {
+      this.setUnavailableError(error, {
+        operation: "app_center.refresh",
+        workspaceId: normalizedWorkspaceId
+      });
+    }
+  }
+  async refreshCatalog(workspaceId) {
+    const normalizedWorkspaceId = workspaceId.trim();
+    if (!normalizedWorkspaceId) {
+      return;
+    }
+    const sequence = ++this.appLoadSequence;
+    this.store.workspaceId = normalizedWorkspaceId;
+    this.store.error = null;
+    try {
+      const snapshot = await this.dependencies.gateway.refreshWorkspaceAppCatalog(
+        normalizedWorkspaceId
+      );
+      if (sequence !== this.appLoadSequence) {
+        this.dependencies.hooks?.onRefreshDiscard?.({
+          currentSequence: this.appLoadSequence,
+          itemCount: snapshot.apps.length,
+          operation: "app_center.refresh_catalog",
+          sequence,
+          snapshotKind: "catalog_apps",
+          workspaceId: normalizedWorkspaceId
+        });
+        return;
+      }
+      this.applySnapshot(normalizedWorkspaceId, snapshot);
+      this.dependencies.hooks?.onCatalogRefreshed?.({
+        appCount: snapshot.apps.length,
+        errorReason: null,
+        success: true
+      });
+    } catch (error) {
+      if (sequence !== this.appLoadSequence) {
+        this.dependencies.hooks?.onRefreshDiscard?.({
+          currentSequence: this.appLoadSequence,
+          operation: "app_center.refresh_catalog",
+          sequence,
+          snapshotKind: "catalog_apps",
+          workspaceId: normalizedWorkspaceId
+        });
+        return;
+      }
+      this.setUnavailableError(error, {
+        operation: "app_center.refresh_catalog",
+        workspaceId: normalizedWorkspaceId
+      });
+      this.dependencies.hooks?.onCatalogRefreshed?.({
+        appCount: null,
+        errorReason: this.getErrorReason(error),
+        success: false
+      });
+    }
+  }
+  async startEnabledApps(workspaceId) {
+    this.markEnabledAppsStarting();
+    try {
+      const snapshot = await this.dependencies.gateway.startEnabledWorkspaceApps(workspaceId);
+      this.applySnapshot(workspaceId, snapshot);
+    } catch (error) {
+      this.setUnavailableError(error, {
+        operation: "workspace_app.start_enabled",
+        workspaceId
+      });
+    }
+  }
+  async uninstallApp(input) {
+    const app = this.store.apps.find(
+      (candidate) => candidate.appId === input.appId
+    );
+    const snapshot = await this.dependencies.gateway.uninstallWorkspaceApp(
+      input.workspaceId,
+      input.appId
+    );
+    this.applySnapshot(input.workspaceId, snapshot);
+    this.dependencies.hooks?.onAppUninstalled?.(app ?? null);
+  }
+  async updateApp(input) {
+    const installKey = appRuntimeKey(input.workspaceId, input.appId);
+    if (this.pendingInstallKeys.has(installKey)) {
+      return;
+    }
+    const app = this.store.apps.find(
+      (candidate) => candidate.appId === input.appId
+    );
+    const previousApps = this.store.apps;
+    this.pendingInstallKeys.add(installKey);
+    this.markAppInstalling(input.appId, { preserveInstalled: true });
+    try {
+      const snapshot = await this.dependencies.gateway.installWorkspaceApp(
+        input.workspaceId,
+        input.appId
+      );
+      this.applySnapshot(input.workspaceId, snapshot);
+      this.dependencies.hooks?.onAppUpdated?.({
+        app,
+        trigger: input.trigger
+      });
+      if (this.pendingInstallKeys.has(installKey)) {
+        this.scheduleInstallRefresh(input.workspaceId, input.appId);
+      }
+    } catch (error) {
+      this.pendingInstallKeys.delete(installKey);
+      this.clearInstallRefreshTimer(input.workspaceId, input.appId);
+      this.store.apps = previousApps;
+      this.setOperationError(error, {
+        appId: input.appId,
+        operation: "workspace_app.update",
+        uiAction: "update_app",
+        workspaceId: input.workspaceId
+      });
+    }
+  }
+  async retryApp(input) {
+    const app = this.store.apps.find(
+      (candidate) => candidate.appId === input.appId
+    );
+    if (this.store.workspaceId !== input.workspaceId || !app?.installed || app.runtimeStatus !== "failed") {
+      return;
+    }
+    const previousApps = this.store.apps;
+    this.markAppStarting(input.appId);
+    try {
+      const snapshot = await this.dependencies.gateway.retryWorkspaceApp(
+        input.workspaceId,
+        input.appId
+      );
+      this.applySnapshot(input.workspaceId, snapshot);
+    } catch (error) {
+      if (this.store.workspaceId === input.workspaceId) {
+        this.store.apps = previousApps;
+      }
+      this.setOperationError(error, {
+        appId: input.appId,
+        operation: "workspace_app.retry",
+        uiAction: "retry_app",
+        workspaceId: input.workspaceId
+      });
+    }
+  }
+  waitForLaunchableApp(input) {
+    const current = this.resolveLaunchableApp(input);
+    if (current) {
+      return Promise.resolve(current);
+    }
+    if (this.shouldAbortLaunchWait(input)) {
+      return Promise.resolve(null);
+    }
+    const launchWaitTimeoutMs = this.dependencies.appOpenLaunchWaitTimeoutMs ?? defaultAppOpenLaunchWaitTimeoutMs;
+    return new Promise((resolve) => {
+      let settled = false;
+      let unsubscribe = noop;
+      let timeout = null;
+      const settle = (app) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        unsubscribe();
+        resolve(app);
+      };
+      timeout = setTimeout(() => {
+        void this.refreshLaunchWaitState(input).then((app) => {
+          if (!app) {
+            this.markLaunchWaitTimedOut(input);
+          }
+          settle(app);
+        });
+      }, launchWaitTimeoutMs);
+      unsubscribe = this.subscribe(() => {
+        const app = this.store.apps.find(
+          (candidate) => candidate.appId === input.appId
+        );
+        if (this.shouldAbortLaunchWait(input, app)) {
+          settle(null);
+          return;
+        }
+        const launchable = this.resolveLaunchableApp(input);
+        if (launchable) {
+          settle(launchable);
+        }
+      });
+    });
+  }
+  async refreshLaunchWaitState(input) {
+    try {
+      const snapshot = await this.dependencies.gateway.listWorkspaceApps(
+        input.workspaceId
+      );
+      this.applySnapshot(input.workspaceId, snapshot);
+    } catch (error) {
+      this.setOperationError(error, {
+        appId: input.appId,
+        operation: "workspace_app.refresh_launch_wait_state",
+        uiAction: "refresh_launch_wait_state",
+        workspaceId: input.workspaceId
+      });
+      return null;
+    }
+    return this.resolveLaunchableApp(input);
+  }
+  shouldAbortLaunchWait(input, app = this.store.apps.find((candidate) => candidate.appId === input.appId)) {
+    return this.store.workspaceId !== input.workspaceId || !app?.installed || app.runtimeStatus === "failed";
+  }
+};
+
+// src/core/appIdentity.ts
+var workspaceAppIdPattern = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+function isWorkspaceAppId(value) {
+  return workspaceAppIdPattern.test(value);
+}
+function normalizeWorkspaceAppId(value) {
+  return value.trim().toLowerCase();
+}
+function createWorkspaceAppIdentity(input) {
+  return normalizeWorkspaceAppId(input.id);
+}
+
+// src/core/manifestValidation.ts
+var appWindowMinWidth = 280;
+var appWindowMinHeight = 160;
+var appWindowMaxWidth = 1600;
+var appWindowMaxHeight = 1200;
+function validateWorkspaceAppManifest(value) {
+  const issues = [];
+  if (!isRecord(value)) {
+    return {
+      issues: [
+        {
+          code: "manifest.notObject",
+          message: "Manifest must be an object.",
+          path: "$"
+        }
+      ],
+      valid: false
+    };
+  }
+  if (value.schemaVersion !== workspaceAppManifestSchemaVersion) {
+    issues.push({
+      code: "manifest.schemaVersion",
+      message: `schemaVersion must be ${workspaceAppManifestSchemaVersion}.`,
+      path: "$.schemaVersion"
+    });
+  }
+  const appId = readOptionalString(value.appId);
+  if (!appId || !isWorkspaceAppId(normalizeWorkspaceAppId(appId))) {
+    issues.push({
+      code: "manifest.appId",
+      message: "appId must contain lowercase letters, numbers, dots, hyphens, or underscores.",
+      path: "$.appId"
+    });
+  }
+  const name = readOptionalString(value.name);
+  if (!name) {
+    issues.push({
+      code: "manifest.name",
+      message: "name is required.",
+      path: "$.name"
+    });
+  }
+  const version = readOptionalString(value.version);
+  if (!version) {
+    issues.push({
+      code: "manifest.version",
+      message: "version is required.",
+      path: "$.version"
+    });
+  }
+  const description = readOptionalString(value.description);
+  if (!description) {
+    issues.push({
+      code: "manifest.description",
+      message: "description is required.",
+      path: "$.description"
+    });
+  }
+  const icon = validateIcon(value.icon, issues);
+  const runtime = validateRuntime(value.runtime, issues);
+  const window = validateWindow(value.window, issues);
+  const author = validateAuthor(value.author, issues);
+  const references = validateReferences(value.references, issues);
+  const tags = validateTags(value.tags, issues);
+  const localizationInfo = validateLocalizationInfo(
+    value.localizationInfo,
+    issues
+  );
+  if (issues.length > 0 || !appId || !name || !version || !description || !runtime) {
+    return {
+      issues,
+      valid: false
+    };
+  }
+  return {
+    issues,
+    manifest: {
+      schemaVersion: workspaceAppManifestSchemaVersion,
+      appId: normalizeWorkspaceAppId(appId),
+      name,
+      version,
+      description,
+      ...icon ? { icon } : {},
+      runtime,
+      ...window ? { window } : {},
+      ...author ? { author } : {},
+      ...references ? { references } : {},
+      ...tags ? { tags } : {},
+      ...localizationInfo ? { localizationInfo } : {}
+    },
+    valid: true
+  };
+}
+function validateIcon(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.icon",
+      message: "icon must be an object when provided.",
+      path: "$.icon"
+    });
+    return void 0;
+  }
+  const type = value.type;
+  const src = readOptionalString(value.src);
+  if (type !== "asset" || !src || !isRelativePackagePath(src)) {
+    issues.push({
+      code: "manifest.icon",
+      message: "icon must include type=asset and a relative src.",
+      path: "$.icon"
+    });
+    return void 0;
+  }
+  return {
+    type,
+    src
+  };
+}
+function validateRuntime(value, issues) {
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.runtime",
+      message: "runtime is required.",
+      path: "$.runtime"
+    });
+    return void 0;
+  }
+  const bootstrap = readOptionalString(value.bootstrap);
+  const healthcheckPath = readOptionalString(value.healthcheckPath);
+  if (!bootstrap || !isRelativePackagePath(bootstrap)) {
+    issues.push({
+      code: "manifest.runtime",
+      message: "runtime.bootstrap must be a relative package path.",
+      path: "$.runtime.bootstrap"
+    });
+  }
+  if (!healthcheckPath || !healthcheckPath.startsWith("/")) {
+    issues.push({
+      code: "manifest.runtime",
+      message: "runtime.healthcheckPath must start with /.",
+      path: "$.runtime.healthcheckPath"
+    });
+  }
+  if (!bootstrap || !healthcheckPath || !isRelativePackagePath(bootstrap) || !healthcheckPath.startsWith("/")) {
+    return void 0;
+  }
+  return {
+    bootstrap,
+    healthcheckPath
+  };
+}
+function validateWindow(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.window",
+      message: "window must be an object when provided.",
+      path: "$.window"
+    });
+    return void 0;
+  }
+  const minimizeBehavior = value.minimizeBehavior;
+  if (minimizeBehavior !== void 0 && minimizeBehavior !== "keep-mounted" && minimizeBehavior !== "hibernate") {
+    issues.push({
+      code: "manifest.window",
+      message: "window.minimizeBehavior must be keep-mounted or hibernate when provided.",
+      path: "$.window.minimizeBehavior"
+    });
+    return void 0;
+  }
+  const minWidth = validateWindowSize(
+    value.minWidth,
+    "minWidth",
+    appWindowMinWidth,
+    appWindowMaxWidth,
+    issues
+  );
+  const minHeight = validateWindowSize(
+    value.minHeight,
+    "minHeight",
+    appWindowMinHeight,
+    appWindowMaxHeight,
+    issues
+  );
+  if (minWidth === null || minHeight === null) {
+    return void 0;
+  }
+  return {
+    ...minimizeBehavior ? { minimizeBehavior } : {},
+    ...minHeight === void 0 ? {} : { minHeight },
+    ...minWidth === void 0 ? {} : { minWidth }
+  };
+}
+function validateWindowSize(value, field, minimum, maximum, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < minimum || value > maximum) {
+    issues.push({
+      code: "manifest.window",
+      message: `window.${field} must be an integer between ${minimum} and ${maximum} when provided.`,
+      path: `$.window.${field}`
+    });
+    return null;
+  }
+  return value;
+}
+function validateAuthor(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.author",
+      message: "author must be an object when provided.",
+      path: "$.author"
+    });
+    return void 0;
+  }
+  const name = readOptionalString(value.name);
+  const url = readOptionalString(value.url);
+  if (!name || value.url !== void 0 && !url) {
+    issues.push({
+      code: "manifest.author",
+      message: "author must include name and an optional non-empty url.",
+      path: "$.author"
+    });
+    return void 0;
+  }
+  return {
+    name,
+    ...url ? { url } : {}
+  };
+}
+function validateReferences(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.references",
+      message: "references must be an object when provided.",
+      path: "$.references"
+    });
+    return void 0;
+  }
+  const searchEndpoint = readOptionalString(value.searchEndpoint);
+  if (!searchEndpoint || !isRelativeUrlPath(searchEndpoint)) {
+    issues.push({
+      code: "manifest.references",
+      message: "references.searchEndpoint must be a relative URL path without query or hash.",
+      path: "$.references.searchEndpoint"
+    });
+    return void 0;
+  }
+  return { searchEndpoint };
+}
+function validateTags(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    issues.push({
+      code: "manifest.tags",
+      message: "tags must be an array when provided.",
+      path: "$.tags"
+    });
+    return void 0;
+  }
+  const tags = value.map((tag) => readOptionalString(tag)).filter((tag) => Boolean(tag));
+  if (tags.length !== value.length) {
+    issues.push({
+      code: "manifest.tags",
+      message: "tags must only contain non-empty strings.",
+      path: "$.tags"
+    });
+  }
+  return Array.from(new Set(tags));
+}
+function validateLocalizationInfo(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.localizationInfo",
+      message: "localizationInfo must be an object when provided.",
+      path: "$.localizationInfo"
+    });
+    return void 0;
+  }
+  const defaultLocale = readOptionalString(value.defaultLocale);
+  if (!defaultLocale) {
+    issues.push({
+      code: "manifest.localizationInfo",
+      message: "localizationInfo.defaultLocale is required.",
+      path: "$.localizationInfo.defaultLocale"
+    });
+  }
+  const additionalLocalesValue = value.additionalLocales;
+  if (additionalLocalesValue !== void 0 && !Array.isArray(additionalLocalesValue)) {
+    issues.push({
+      code: "manifest.localizationInfo",
+      message: "localizationInfo.additionalLocales must be an array.",
+      path: "$.localizationInfo.additionalLocales"
+    });
+    return void 0;
+  }
+  const seenLocales = new Set(
+    defaultLocale ? [defaultLocale.toLowerCase()] : []
+  );
+  const additionalLocales = [];
+  for (const [index, entry] of (additionalLocalesValue ?? []).entries()) {
+    if (!isRecord(entry)) {
+      issues.push({
+        code: "manifest.localizationInfo",
+        message: "localizationInfo.additionalLocales entries must be objects.",
+        path: `$.localizationInfo.additionalLocales[${index}]`
+      });
+      continue;
+    }
+    const locale = readOptionalString(entry.locale);
+    const file = readOptionalString(entry.file);
+    if (!locale || !file || !isRelativePackagePath(file)) {
+      issues.push({
+        code: "manifest.localizationInfo",
+        message: "localizationInfo.additionalLocales entries must include locale and a relative file path.",
+        path: `$.localizationInfo.additionalLocales[${index}]`
+      });
+      continue;
+    }
+    const localeKey = locale.toLowerCase();
+    if (seenLocales.has(localeKey)) {
+      issues.push({
+        code: "manifest.localizationInfo",
+        message: "localizationInfo locales must be unique.",
+        path: `$.localizationInfo.additionalLocales[${index}].locale`
+      });
+      continue;
+    }
+    seenLocales.add(localeKey);
+    additionalLocales.push({ locale, file });
+  }
+  if (!defaultLocale || issues.some((issue) => issue.code === "manifest.localizationInfo")) {
+    return void 0;
+  }
+  return {
+    defaultLocale,
+    ...additionalLocales.length > 0 ? { additionalLocales } : {}
+  };
+}
+function readOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function isRelativePackagePath(value) {
+  return !value.startsWith("/") && !value.split(/[\\/]/u).includes("..");
+}
+function isRelativeUrlPath(value) {
+  const trimmed = value.trim();
+  if (!trimmed || !trimmed.startsWith("/") || trimmed.startsWith("//") || trimmed.includes("\0") || trimmed.includes("?") || trimmed.includes("#") || trimmed.includes("%")) {
+    return false;
+  }
+  return true;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/statusMapping.ts
+var statusAliases = /* @__PURE__ */ new Map([
+  ["active", "running"],
+  ["created", "idle"],
+  ["crashed", "failed"],
+  ["error", "failed"],
+  ["failed", "failed"],
+  ["idle", "idle"],
+  ["installed", "idle"],
+  ["installing", "installing"],
+  ["downloading_runtime", "preparing"],
+  ["launching", "starting"],
+  ["pending", "starting"],
+  ["preparing", "preparing"],
+  ["ready", "idle"],
+  ["running", "running"],
+  ["runner_unavailable", "unavailable"],
+  ["runtime_unavailable", "unavailable"],
+  ["sandbox_unavailable", "unavailable"],
+  ["started", "running"],
+  ["starting", "starting"],
+  ["stale", "unavailable"],
+  ["stopped", "idle"],
+  ["stopping", "stopping"],
+  ["terminated", "idle"],
+  ["terminating", "stopping"],
+  ["unavailable", "unavailable"],
+  ["unreachable", "unavailable"]
+]);
+function mapWorkspaceAppRuntimeStatus(value) {
+  if (typeof value !== "string") {
+    return "idle";
+  }
+  return statusAliases.get(value.trim().toLowerCase()) ?? "idle";
+}
+function normalizeWorkspaceAppRuntimeState(state) {
+  return {
+    ...state,
+    status: mapWorkspaceAppRuntimeStatus(state.status)
+  };
+}
+function resolveWorkspaceAppStatusPresentation(status) {
+  switch (status) {
+    case "installing":
+      return {
+        labelKey: "status.installing",
+        pulse: true,
+        tone: "blue"
+      };
+    case "preparing":
+      return {
+        labelKey: "status.preparing",
+        pulse: true,
+        tone: "blue"
+      };
+    case "starting":
+      return {
+        labelKey: "status.starting",
+        pulse: true,
+        tone: "blue"
+      };
+    case "running":
+      return {
+        labelKey: "status.running",
+        pulse: false,
+        tone: "green"
+      };
+    case "failed":
+      return {
+        labelKey: "status.failed",
+        pulse: false,
+        tone: "red"
+      };
+    case "stopping":
+      return {
+        labelKey: "status.stopping",
+        pulse: true,
+        tone: "amber"
+      };
+    case "unavailable":
+      return {
+        labelKey: "status.unavailable",
+        pulse: false,
+        tone: "amber"
+      };
+    case "idle":
+      return {
+        labelKey: "actions.openApp",
+        pulse: false,
+        tone: "neutral"
+      };
+  }
+}
+
+// src/core/appCenterViewModel.ts
+function createAppCenterViewModel({
+  apps,
+  factoryJobs = [],
+  locale = null,
+  replaceableIconAppIds = [],
+  runtimeStates = []
+}) {
+  const runtimeStateMaps = createRuntimeStateMaps(runtimeStates);
+  const appFactoryJobByAppId = createAppFactoryJobByAppId(factoryJobs);
+  const replaceableIconAppIdSet = new Set(
+    replaceableIconAppIds.map((appId) => appId.trim()).filter(Boolean)
+  );
+  const appCards = apps.map((app) => {
+    const installationId = normalizeOptionalString(
+      app.install?.installationId
+    );
+    const runtime = findRuntimeStateForApp(
+      runtimeStateMaps,
+      app.manifest.appId,
+      installationId
+    );
+    const factoryJob = appFactoryJobByAppId.get(app.manifest.appId);
+    const metadata = resolveWorkspaceAppCatalogMetadata({
+      catalog: app.catalog,
+      locale,
+      manifest: app.manifest
+    });
+    const factoryAgentSessionId = factoryJob?.agentSessionId?.trim() || null;
+    const status = runtime?.status ?? "idle";
+    const presentation = resolveWorkspaceAppStatusPresentation(status);
+    const installed = Boolean(app.install);
+    const sourceKind = resolveCatalogSourceKind(app.catalog);
+    const localApp = sourceKind === "local";
+    const runtimeId = normalizeOptionalString(runtime?.runtimeId);
+    const launchUrl = normalizeOptionalString(runtime?.launchUrl);
+    const installedVersion = normalizeOptionalString(app.install?.version);
+    const manifestVersion = normalizeOptionalString(app.manifest.version);
+    const displayVersion = installedVersion ?? manifestVersion;
+    const comingSoon = isComingSoonApp(metadata.tags) || isComingSoonApp(app.manifest.tags ?? []);
+    const busy = isBusyRuntimeStatus(status);
+    const unavailable = status === "unavailable";
+    const canUpdate = !comingSoon && !busy && !unavailable && installed && (app.updateAvailable ?? false);
+    const canOpen = !comingSoon && installed && canOpenInstalledApp(status);
+    const canRetry = installed && status === "failed";
+    const primaryAction = resolvePrimaryAction({
+      canOpen,
+      canRetry,
+      canUpdate,
+      comingSoon,
+      installed,
+      status
+    });
+    return {
+      id: app.manifest.appId,
+      installationId,
+      runtimeId,
+      launchUrl,
+      name: metadata.name,
+      createdAtUnixMs: app.createdAtUnixMs ?? null,
+      ...metadata.description ? { description: metadata.description } : {},
+      ...displayVersion && !comingSoon ? { version: displayVersion } : {},
+      ...app.availableVersion && !comingSoon ? { availableVersion: app.availableVersion } : {},
+      ...app.category?.trim() ? { category: app.category.trim() } : {},
+      updateAvailable: app.updateAvailable ?? false,
+      ...app.manifest.icon ? { icon: app.manifest.icon } : {},
+      tags: metadata.tags,
+      installed,
+      status,
+      statusLabelKey: comingSoon ? "status.comingSoon" : resolvePrimaryActionLabelKey(primaryAction, presentation.labelKey),
+      statusTone: presentation.tone,
+      statusPulse: presentation.pulse,
+      primaryAction,
+      sourceKind,
+      canOpen,
+      canExport: localApp,
+      canDelete: localApp,
+      canReplaceIcon: replaceableIconAppIdSet.has(app.manifest.appId),
+      canOpenFolder: installed,
+      canOpenPackageFolder: installed && localApp && Boolean(displayVersion),
+      canOpenFactorySession: Boolean(factoryAgentSessionId),
+      canPublishFactoryUpdate: installed && factoryJob?.status === "ready" && Boolean(factoryJob.publishedVersion?.trim()),
+      canUninstall: installed,
+      canRetry,
+      canUpdate,
+      ...factoryAgentSessionId ? { factoryAgentSessionId } : {},
+      ...factoryJob?.jobId ? { factoryJobId: factoryJob.jobId } : {},
+      ...factoryJob?.provider ? { factoryProvider: factoryJob.provider } : {},
+      ...runtime?.error?.message ? { errorMessage: runtime.error.message } : {}
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    apps: appCards,
+    factoryJobs: factoryJobs.filter((job) => !isPublishedAppFactoryJob(job)).map(createFactoryJobViewModel),
+    empty: appCards.length === 0,
+    failedCount: appCards.filter((app) => app.status === "failed").length,
+    installedCount: appCards.filter((app) => app.installed).length,
+    runningCount: appCards.filter((app) => app.status === "running").length
+  };
+}
+function createRuntimeStateMaps(runtimeStates) {
+  const fallbackByAppId = /* @__PURE__ */ new Map();
+  const byInstallationId = /* @__PURE__ */ new Map();
+  for (const state of runtimeStates) {
+    const runtime = {
+      ...state,
+      status: mapWorkspaceAppRuntimeStatus(state.status)
+    };
+    const installationId = normalizeOptionalString(runtime.installationId);
+    if (installationId) {
+      byInstallationId.set(installationId, runtime);
+      continue;
+    }
+    const appId = normalizeOptionalString(runtime.appId);
+    if (appId) {
+      fallbackByAppId.set(appId, runtime);
+    }
+  }
+  return {
+    fallbackByAppId,
+    byInstallationId
+  };
+}
+function findRuntimeStateForApp(maps, appId, installationId) {
+  if (installationId) {
+    const runtime = maps.byInstallationId.get(installationId);
+    if (runtime) {
+      return runtime;
+    }
+  }
+  return maps.fallbackByAppId.get(appId);
+}
+function resolveCatalogSourceKind(catalog) {
+  return catalog?.source?.kind ?? "bundled";
+}
+function resolveWorkspaceAppCatalogMetadata(input) {
+  const manifest = input.manifest;
+  const localization = findWorkspaceAppCatalogLocalization(
+    input.catalog,
+    input.locale
+  );
+  const name = localization?.name?.trim() || manifest.name;
+  const description = localization?.description?.trim() || manifest.description || "";
+  const tags = localization?.tags?.map((tag) => tag.trim()).filter((tag) => tag.length > 0) ?? manifest.tags ?? [];
+  return {
+    description,
+    name,
+    tags: Array.from(new Set(tags))
+  };
+}
+function findWorkspaceAppCatalogLocalization(catalog, locale) {
+  const localizations = catalog?.localizations ?? [];
+  const normalizedLocale = normalizeLocale(locale);
+  if (!normalizedLocale || localizations.length === 0) {
+    return null;
+  }
+  const exact = localizations.find(
+    (localization) => normalizeLocale(localization.locale) === normalizedLocale
+  );
+  if (exact) {
+    return exact;
+  }
+  const language = normalizedLocale.split("-")[0];
+  if (!language) {
+    return null;
+  }
+  return localizations.find(
+    (localization) => normalizeLocale(localization.locale)?.split("-")[0] === language
+  ) ?? null;
+}
+function normalizeLocale(value) {
+  const normalized = value?.trim().replace(/_/gu, "-").toLowerCase() ?? "";
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeOptionalString(value) {
+  const normalized = value?.trim() ?? "";
+  return normalized.length > 0 ? normalized : null;
+}
+function resolvePrimaryAction(input) {
+  if (input.comingSoon) {
+    return "none";
+  }
+  if (isBusyRuntimeStatus(input.status)) {
+    return "none";
+  }
+  if (input.status === "unavailable") {
+    return "none";
+  }
+  if (!input.installed) {
+    return "install";
+  }
+  if (input.canUpdate) {
+    return "update";
+  }
+  if (input.canRetry) {
+    return "retry";
+  }
+  if (input.canOpen) {
+    return "open";
+  }
+  return "none";
+}
+function isComingSoonApp(tags) {
+  return tags.some((tag) => tag.trim().toLowerCase() === "coming-soon");
+}
+function canOpenInstalledApp(status) {
+  return status === "idle" || status === "running";
+}
+function isBusyRuntimeStatus(status) {
+  return status === "installing" || status === "preparing" || status === "starting" || status === "stopping";
+}
+function resolvePrimaryActionLabelKey(primaryAction, fallbackLabelKey) {
+  switch (primaryAction) {
+    case "install":
+      return "actions.installApp";
+    case "open":
+      return "actions.openApp";
+    case "retry":
+      return "actions.retryApp";
+    case "update":
+      return "actions.updateApp";
+    case "none":
+      return fallbackLabelKey;
+  }
+}
+function createAppFactoryJobByAppId(factoryJobs) {
+  const result = /* @__PURE__ */ new Map();
+  for (const job of [...factoryJobs].sort(
+    (left, right) => right.updatedAtUnixMs - left.updatedAtUnixMs
+  )) {
+    if (!isPublishedAppFactoryJob(job)) {
+      continue;
+    }
+    const appId = job.appId?.trim();
+    if (!appId || result.has(appId)) {
+      continue;
+    }
+    result.set(appId, job);
+  }
+  return result;
+}
+function isPublishedAppFactoryJob(job) {
+  return job.status === "published" || Boolean(job.publishedVersion?.trim());
+}
+function createFactoryJobViewModel(job) {
+  const statusLabelKey = `factory.status.${job.status}`;
+  const title = job.displayName.trim();
+  const agentSessionId = job.agentSessionId?.trim() || null;
+  const canFixValidationFailure = job.status === "failed" && job.validationResult != null;
+  return {
+    id: job.jobId,
+    agentSessionId,
+    appId: job.appId,
+    title,
+    prompt: job.prompt,
+    provider: job.provider,
+    status: job.status,
+    statusLabelKey,
+    canCancel: job.status === "queued" || job.status === "generating" || job.status === "preparing" || job.status === "validating",
+    canDelete: job.status === "canceled" || job.status === "failed" || job.status === "published" || job.status === "ready",
+    canFix: canFixValidationFailure,
+    canOpenAgentSession: Boolean(agentSessionId),
+    canPublish: job.status === "ready",
+    canRetryValidation: canFixValidationFailure,
+    failureReason: job.failureReason,
+    updatedAtUnixMs: job.updatedAtUnixMs
+  };
+}
+function createWorkspaceAppRecord(input) {
+  const manifest = input.catalog?.manifest;
+  if (!manifest) {
+    throw new Error("catalog manifest is required.");
+  }
+  return {
+    catalog: input.catalog,
+    category: input.category,
+    createdAtUnixMs: input.createdAtUnixMs ?? null,
+    install: input.install ?? null,
+    manifest
+  };
+}
+
+export {
+  createWorkspaceAppCenterStoreState,
+  createWorkspaceAppCenterController,
+  WorkspaceAppCenterController,
+  workspaceAppIdPattern,
+  isWorkspaceAppId,
+  normalizeWorkspaceAppId,
+  createWorkspaceAppIdentity,
+  validateWorkspaceAppManifest,
+  mapWorkspaceAppRuntimeStatus,
+  normalizeWorkspaceAppRuntimeState,
+  resolveWorkspaceAppStatusPresentation,
+  createAppCenterViewModel,
+  resolveWorkspaceAppCatalogMetadata,
+  createWorkspaceAppRecord
+};
+//# sourceMappingURL=chunk-5SANC3S6.js.map