sh3-core 0.13.1 → 0.13.3

package/dist/projects-shard/projectsApi.js

@@ -0,0 +1,44 @@
+/*
+ * Client wrapper for the /api/projects HTTP surface.
+ *
+ * Returns plain JSON objects; the shard layer is responsible for keeping
+ * a reactive copy and for converting these to actions / views.
+ */
+async function jsonFetch(url, init) {
+    var _a;
+    const res = await fetch(url, Object.assign({ credentials: 'include' }, init));
+    if (!res.ok)
+        throw new Error(`${(_a = init === null || init === void 0 ? void 0 : init.method) !== null && _a !== void 0 ? _a : 'GET'} ${url} failed: ${res.status}`);
+    return res.json();
+}
+export const projectsApi = {
+    async list() {
+        const body = await jsonFetch('/api/projects', { method: 'GET' });
+        return body.projects;
+    },
+    async listAll() {
+        const body = await jsonFetch('/api/projects/all', { method: 'GET' });
+        return body.projects;
+    },
+    async get(id) {
+        return jsonFetch(`/api/projects/${encodeURIComponent(id)}`, { method: 'GET' });
+    },
+    async create(input) {
+        return jsonFetch('/api/projects', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(input),
+        });
+    },
+    async update(id, patch) {
+        return jsonFetch(`/api/projects/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(patch),
+        });
+    },
+    async delete(id, opts) {
+        const qs = (opts === null || opts === void 0 ? void 0 : opts.wipeData) ? '?wipeData=1' : '';
+        await jsonFetch(`/api/projects/${encodeURIComponent(id)}${qs}`, { method: 'DELETE' });
+    },
+};

package/dist/projects-shard/projectsApi.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/projects-shard/projectsApi.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { projectsApi } from './projectsApi';
+describe('projectsApi', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    it('list() GETs /api/projects and returns projects array', async () => {
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ projects: [{ id: 'acme-abcd', name: 'Acme', members: [], appAllowlist: [], createdBy: 'admin', createdAt: 0, updatedAt: 0 }] }),
+        });
+        const projects = await projectsApi.list();
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects', expect.objectContaining({ method: 'GET' }));
+        expect(projects).toHaveLength(1);
+        expect(projects[0].name).toBe('Acme');
+    });
+    it('listAll() GETs /api/projects/all', async () => {
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ projects: [] }),
+        });
+        await projectsApi.listAll();
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects/all', expect.objectContaining({ method: 'GET' }));
+    });
+    it('create() POSTs JSON body to /api/projects', async () => {
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ id: 'x-1234', name: 'X', members: [], appAllowlist: [], createdBy: 'admin', createdAt: 0, updatedAt: 0 }),
+        });
+        const project = await projectsApi.create({ name: 'X', members: [], appAllowlist: [] });
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects', expect.objectContaining({ method: 'POST' }));
+        expect(project.id).toBe('x-1234');
+    });
+    it('update() PATCHes /api/projects/:id', async () => {
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ id: 'a', name: 'A', members: [], appAllowlist: [], createdBy: 'admin', createdAt: 0, updatedAt: 0 }),
+        });
+        await projectsApi.update('a', { name: 'A' });
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects/a', expect.objectContaining({ method: 'PATCH' }));
+    });
+    it('delete() DELETEs /api/projects/:id', async () => {
+        globalThis.fetch.mockResolvedValue({ ok: true, json: async () => ({ ok: true }) });
+        await projectsApi.delete('a');
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects/a', expect.objectContaining({ method: 'DELETE' }));
+    });
+    it('throws on non-ok response', async () => {
+        globalThis.fetch.mockResolvedValue({ ok: false, status: 403 });
+        await expect(projectsApi.list()).rejects.toThrow(/403/);
+    });
+});
+describe('projectsApi.delete with wipeData', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    it('appends ?wipeData=1 when opts.wipeData is true', async () => {
+        globalThis.fetch.mockResolvedValue({ ok: true, json: async () => ({ ok: true, wipedData: true }) });
+        await projectsApi.delete('a', { wipeData: true });
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects/a?wipeData=1', expect.objectContaining({ method: 'DELETE' }));
+    });
+    it('does not append the query when opts is omitted', async () => {
+        globalThis.fetch.mockResolvedValue({ ok: true, json: async () => ({ ok: true, wipedData: false }) });
+        await projectsApi.delete('a');
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects/a', expect.objectContaining({ method: 'DELETE' }));
+    });
+    it('does not append the query when opts.wipeData is false', async () => {
+        globalThis.fetch.mockResolvedValue({ ok: true, json: async () => ({ ok: true, wipedData: false }) });
+        await projectsApi.delete('a', { wipeData: false });
+        expect(globalThis.fetch).toHaveBeenCalledWith('/api/projects/a', expect.objectContaining({ method: 'DELETE' }));
+    });
+});

package/dist/projects-shard/projectsShard.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Shard } from '../shards/types';
+import { type ProjectRecord } from './projectsApi';
+export declare const projectsState: {
+    projects: ProjectRecord[];
+    loading: boolean;
+    error: string | null;
+};
+export declare function refreshProjects(): Promise<void>;
+export declare function openProjectManage(project: ProjectRecord | null): void;
+export declare const projectsShard: Shard;

package/dist/projects-shard/projectsShard.svelte.js

@@ -0,0 +1,148 @@
+/*
+ * `__projects__` shard — multi-member project scope module.
+ *
+ * Maintains a reactive list of projects the current user is a member of.
+ * Refreshes on activate and on visibility-change so a project created in
+ * one tab appears in another after it regains focus. Registers admin-only
+ * actions that open the ProjectManage float view (create/edit/delete).
+ */
+import { mount, unmount } from 'svelte';
+import { projectsApi } from './projectsApi';
+import { VERSION } from '../version';
+import ProjectManage from './ProjectManage.svelte';
+import { floatManager } from '../overlays/float';
+import { isAdmin } from '../auth/auth.svelte';
+export const projectsState = $state({ projects: [], loading: false, error: null });
+export async function refreshProjects() {
+    projectsState.loading = true;
+    projectsState.error = null;
+    try {
+        projectsState.projects = await projectsApi.list();
+    }
+    catch (e) {
+        projectsState.error = e.message;
+    }
+    finally {
+        projectsState.loading = false;
+    }
+}
+const PROJECTS_MANAGE_VIEW = 'projects:manage';
+/*
+ * The float manager drops `meta` for `dismissable: true` (per the bare
+ * SlotNode wrapper in float.ts). Edit-mode needs to know which project
+ * to load, so we stash the target on a module-level slot the factory
+ * consumes on mount. Cleared after the factory has read it so a later
+ * Create from the palette can't accidentally inherit a previous edit
+ * target.
+ */
+let pendingTarget = null;
+function consumePendingTarget() {
+    const t = pendingTarget;
+    pendingTarget = null;
+    return t;
+}
+export function openProjectManage(project) {
+    pendingTarget = project;
+    floatManager.open(PROJECTS_MANAGE_VIEW, {
+        title: project ? `Edit ${project.name}` : 'Create Project',
+        size: { w: 560, h: 620 },
+        dismissable: true,
+    });
+}
+export const projectsShard = {
+    manifest: {
+        id: '__projects__',
+        label: 'Projects',
+        version: VERSION,
+        views: [{ id: PROJECTS_MANAGE_VIEW, label: 'Project Manager' }],
+    },
+    activate(ctx) {
+        void refreshProjects();
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'visible')
+                    void refreshProjects();
+            });
+        }
+        const factory = {
+            mount(container, _mountCtx) {
+                const project = consumePendingTarget();
+                // The float manager has already pushed an entry for this mount —
+                // the most recent one whose viewId matches us is ours.
+                const list = floatManager.list();
+                const floatId = list.length > 0 ? list[list.length - 1].id : null;
+                const close = () => {
+                    if (floatId)
+                        floatManager.close(floatId);
+                };
+                const instance = mount(ProjectManage, {
+                    target: container,
+                    props: { project, onClose: close },
+                });
+                return {
+                    unmount() {
+                        unmount(instance);
+                    },
+                };
+            },
+        };
+        ctx.registerView(PROJECTS_MANAGE_VIEW, factory);
+        ctx.actions.register({
+            id: 'sh3.project.create',
+            label: 'Create Project…',
+            scope: ['home', 'app'],
+            paletteItem: true,
+            disabled: () => !isAdmin(),
+            run: () => {
+                if (isAdmin())
+                    openProjectManage(null);
+            },
+        });
+        ctx.actions.register({
+            id: 'sh3.project.manage',
+            label: 'Manage Project…',
+            scope: ['home', 'app'],
+            submenu: true,
+            paletteItem: true,
+            disabled: () => !isAdmin(),
+        });
+        // Dynamic children: one per project in projectsState.projects, kept in
+        // sync as projects are created/deleted. Mirrors the sh3.app.launch
+        // pattern in sh3coreShard.
+        const manageUnregisters = new Map();
+        $effect.root(() => {
+            $effect(() => {
+                const currentIds = new Set();
+                for (const project of projectsState.projects) {
+                    currentIds.add(project.id);
+                    if (manageUnregisters.has(project.id))
+                        continue;
+                    const off = ctx.actions.register({
+                        id: `sh3.project.manage:${project.id}`,
+                        label: project.name,
+                        scope: ['home', 'app'],
+                        submenuOf: 'sh3.project.manage',
+                        run: () => {
+                            // Re-read the live record so renames since registration are
+                            // reflected in the form.
+                            const live = projectsState.projects.find((p) => p.id === project.id);
+                            if (live)
+                                openProjectManage(live);
+                        },
+                    });
+                    manageUnregisters.set(project.id, off);
+                }
+                for (const id of [...manageUnregisters.keys()]) {
+                    if (!currentIds.has(id)) {
+                        manageUnregisters.get(id)();
+                        manageUnregisters.delete(id);
+                    }
+                }
+            });
+        });
+    },
+    autostart() {
+        /* register on the self-starting path so the project list is available
+           on the home screen without an app launch. */
+    },
+};

package/dist/sh3core-shard/ShellHome.svelte

@@ -9,19 +9,51 @@
 
   import { listRegisteredApps, launchApp, isAdmin, VERSION } from '../api';
   import ShellTitle from './ShellTitle.svelte';
+  import ProjectsSection from '../projects-shard/ProjectsSection.svelte';
+  import { sessionState } from '../projects/session-state.svelte';
+  import { projectsState } from '../projects-shard/projectsShard.svelte';
+  import { shell } from '../shellRuntime.svelte';
+  import { makeSelectionApi } from '../actions/selection.svelte';
+  import { getAppearance } from '../app-appearance';
+  import iconsUrl from '../assets/icons.svg';
+
+  const homeSelection = makeSelectionApi('__sh3core__');
+
+  function openAppContextMenu(event: MouseEvent, appId: string): void {
+    event.preventDefault();
+    homeSelection.set({ type: 'app', ref: { appId } });
+    shell.actions.openContextMenu({
+      x: event.clientX,
+      y: event.clientY,
+      scope: { element: 'app' },
+    });
+  }
 
   let filter = $state('');
 
   const apps = $derived(listRegisteredApps());
   const elevated = $derived(isAdmin());
 
+  const activeProject = $derived(
+    sessionState.activeProjectId
+      ? projectsState.projects.find((p) => p.id === sessionState.activeProjectId) ?? null
+      : null,
+  );
+
   function matches(m: { id: string; label: string }, q: string): boolean {
     if (!q) return true;
     const needle = q.toLowerCase();
     return m.label.toLowerCase().includes(needle) || m.id.toLowerCase().includes(needle);
   }
 
-  const userApps = $derived(apps.filter((m) => !m.admin && matches(m, filter)));
+  function inAllowlist(appId: string): boolean {
+    if (!activeProject) return true;
+    return activeProject.appAllowlist.includes(appId);
+  }
+
+  const userApps = $derived(
+    apps.filter((m) => !m.admin && matches(m, filter) && inAllowlist(m.id)),
+  );
   const adminApps = $derived(apps.filter((m) => m.admin && matches(m, filter)));
   const totalVisible = $derived(userApps.length + (elevated ? adminApps.length : 0));
 </script>
@@ -48,22 +80,27 @@
     />
   </div>
 
+  <ProjectsSection />
+
   {#if userApps.length > 0}
     <section class="shell-home-section">
       <h2 class="shell-home-section-title">Apps</h2>
       <div class="shell-home-grid">
         {#each userApps as manifest (manifest.id)}
+          {@const appearance = getAppearance(manifest.id)}
           <button
             type="button"
             class="shell-home-card"
+            class:shell-home-card--tinted={appearance?.color}
+            style:--card-color={appearance?.color ?? 'transparent'}
+            data-sh3-scope="element:app"
             onclick={() => launchApp(manifest.id)}
-            title="Launch {manifest.label}"
+            oncontextmenu={(e) => openAppContextMenu(e, manifest.id)}
           >
-            <div class="shell-home-card-label">{manifest.label}</div>
-            <div class="shell-home-card-meta">
-              <span class="shell-home-card-id">{manifest.id}</span>
-              <span class="shell-home-card-version">v{manifest.version}</span>
-            </div>
+            <span class="shell-home-card-square">
+              <svg class="shell-home-card-icon"><use href="{iconsUrl}#{appearance?.icon ?? manifest.icon ?? 'box'}" /></svg>
+            </span>
+            <span class="shell-home-card-label">{appearance?.label ?? manifest.label}</span>
           </button>
         {/each}
       </div>
@@ -75,17 +112,20 @@
       <h2 class="shell-home-section-title">Admin</h2>
       <div class="shell-home-grid">
         {#each adminApps as manifest (manifest.id)}
+          {@const appearance = getAppearance(manifest.id)}
           <button
             type="button"
             class="shell-home-card"
+            class:shell-home-card--tinted={appearance?.color}
+            style:--card-color={appearance?.color ?? 'transparent'}
+            data-sh3-scope="element:app"
             onclick={() => launchApp(manifest.id)}
-            title="Launch {manifest.label}"
+            oncontextmenu={(e) => openAppContextMenu(e, manifest.id)}
           >
-            <div class="shell-home-card-label">{manifest.label}</div>
-            <div class="shell-home-card-meta">
-              <span class="shell-home-card-id">{manifest.id}</span>
-              <span class="shell-home-card-version">v{manifest.version}</span>
-            </div>
+            <span class="shell-home-card-square">
+              <svg class="shell-home-card-icon"><use href="{iconsUrl}#{appearance?.icon ?? manifest.icon ?? 'box'}" /></svg>
+            </span>
+            <span class="shell-home-card-label">{appearance?.label ?? manifest.label}</span>
           </button>
         {/each}
       </div>
@@ -205,26 +245,34 @@
   }
   .shell-home-grid {
     display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(80px, 1fr));
-    gap: 10px;
+    grid-template-columns: repeat(auto-fill, minmax(84px, 1fr));
+    gap: 18px 14px;
   }
   .shell-home-card {
-    aspect-ratio: 1 / 1;
     display: flex;
     flex-direction: column;
-    justify-content: space-between;
-    text-align: left;
-    padding: 10px;
-    background: var(--shell-grad-bg-elevated, var(--shell-bg-elevated));
-    border: 1px solid var(--shell-border);
-    border-radius: var(--shell-radius-md);
+    align-items: center;
+    gap: 6px;
+    padding: 0;
+    background: transparent;
+    border: none;
     color: inherit;
     font: inherit;
     cursor: pointer;
+  }
+  .shell-home-card-square {
+    width: 64px;
+    height: 64px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--shell-grad-bg-elevated, var(--shell-bg-elevated));
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-radius-md);
     box-shadow: 0 2px 6px rgba(0, 0, 0, 0.25), 0 1px 2px rgba(0, 0, 0, 0.15);
     transition: transform 120ms ease, border-color 120ms ease, box-shadow 120ms ease, background 120ms ease;
   }
-  .shell-home-card:hover {
+  .shell-home-card:hover .shell-home-card-square {
     border-color: var(--shell-accent);
     transform: translateY(-1px);
     box-shadow:
@@ -234,36 +282,32 @@
   }
   .shell-home-card:focus-visible {
     outline: none;
+  }
+  .shell-home-card:focus-visible .shell-home-card-square {
     border-color: var(--shell-accent);
     box-shadow: 0 0 0 2px color-mix(in srgb, var(--shell-accent) 40%, transparent);
   }
-  .shell-home-card:active {
+  .shell-home-card:active .shell-home-card-square {
     transform: translateY(0);
   }
   .shell-home-card-label {
     font-weight: 600;
-    font-size: 12px;
+    font-size: 11px;
     line-height: 1.2;
+    text-align: center;
     overflow: hidden;
     display: -webkit-box;
     -webkit-box-orient: vertical;
     -webkit-line-clamp: 2;
     line-clamp: 2;
+    word-break: break-word;
   }
-  .shell-home-card-meta {
-    display: flex;
-    flex-direction: column;
-    gap: 1px;
-    font-size: 9px;
-    color: var(--shell-fg-subtle);
-    min-width: 0;
-  }
-  .shell-home-card-id {
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
+  .shell-home-card-icon {
+    width: 28px;
+    height: 28px;
+    color: var(--shell-fg);
   }
-  .shell-home-card-version {
-    color: var(--shell-fg-muted);
+  .shell-home-card--tinted .shell-home-card-square {
+    background: var(--card-color);
   }
 </style>

package/dist/sh3core-shard/appActions.d.ts

@@ -0,0 +1,13 @@
+import type { ShardContext } from '../shards/types';
+export interface AppActionGate {
+    admin: boolean;
+    builtin: boolean;
+}
+export declare function computeAppActionDisabled(g: AppActionGate): boolean;
+export declare function computeAppActionLabelSuffix(g: AppActionGate): string;
+/**
+ * Register the three element-scope app actions on the given shard context.
+ * Returns a disposer that unregisters all three (the framework expects the
+ * shard's activate to keep the disposers alive across deactivate).
+ */
+export declare function registerAppActions(ctx: ShardContext): () => void;

package/dist/sh3core-shard/appActions.js

@@ -0,0 +1,181 @@
+/*
+ * Element-scope actions for app cards. Wired by sh3coreShard.activate.
+ * The element scope is { element: 'app' } and activates when right-click
+ * on a host with data-sh3-scope="element:app" sets a selection of type
+ * 'app' (see ShellHome.svelte).
+ *
+ * Three actions are registered here:
+ *   - app.info        : info-only row showing "<id> v<version>" (always disabled).
+ *   - app.checkUpdate : refresh catalog, then prompt update or toast up-to-date.
+ *   - app.uninstall   : open uninstall confirm dialog.
+ *
+ * The fourth menu item (app.customize) is registered by the app-appearance
+ * shard so its lifecycle is bound to that shard's activate/deactivate.
+ *
+ * Disabled predicate: !isAdmin || isBuiltin. Built-in means the app id is
+ * NOT in storeContext.state.ephemeral.installed (those are framework-shipped
+ * shards like sh3-store, sh3-shell, projects, etc.).
+ */
+import { listRegisteredApps } from '../api';
+import { isAdmin } from '../auth/auth.svelte';
+import { getSelection } from '../actions/selection.svelte';
+import { storeContext } from '../app/store/storeShard.svelte';
+import { openPermissionConfirmModal } from '../app/store/permissionConfirm';
+import { modalManager } from '../overlays/modal';
+import { toastManager } from '../overlays/toast';
+import AppUpdateAvailableModal from '../app/store/AppUpdateAvailableModal.svelte';
+import UninstallAppDialog from '../app/store/UninstallAppDialog.svelte';
+export function computeAppActionDisabled(g) {
+    return !g.admin || g.builtin;
+}
+export function computeAppActionLabelSuffix(g) {
+    if (!g.admin)
+        return ' · admin only';
+    if (g.builtin)
+        return ' · built-in';
+    return '';
+}
+function readSelection() {
+    const sel = getSelection();
+    if (!sel || sel.type !== 'app')
+        return null;
+    return sel.ref;
+}
+function findApp(appId) {
+    return listRegisteredApps().find((m) => m.id === appId);
+}
+function isBuiltin(appId) {
+    return !storeContext.state.ephemeral.installed.some((p) => p.id === appId);
+}
+function gateFor(appId) {
+    return { admin: isAdmin(), builtin: isBuiltin(appId) };
+}
+async function runCheckUpdate(_ctx) {
+    var _a, _b;
+    const ref = readSelection();
+    if (!ref)
+        return;
+    const { appId } = ref;
+    const checking = toastManager.notify('Checking for updates…', { duration: Infinity });
+    try {
+        await storeContext.refreshCatalog();
+    }
+    finally {
+        checking.close();
+    }
+    const entry = storeContext.state.ephemeral.updatable[appId];
+    const installed = storeContext.state.ephemeral.installed.find((p) => p.id === appId);
+    const label = (_b = (_a = findApp(appId)) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : appId;
+    if (!entry || !installed) {
+        toastManager.notify(`${label} is up to date`, { level: 'info', duration: 2500 });
+        return;
+    }
+    const props = {
+        appId,
+        appLabel: label,
+        fromVersion: installed.version,
+        toVersion: entry.latest.version,
+        onConfirm: async () => {
+            try {
+                await storeContext.updatePackage(appId, (added, removed) => openPermissionConfirmModal({ label: installed.id, version: installed.version }, entry.latest.version, added, removed));
+                toastManager.notify(`Updated to v${entry.latest.version}`, { level: 'success' });
+            }
+            catch (e) {
+                toastManager.notify(`Update failed: ${e.message}`, { level: 'error', duration: 5000 });
+                throw e;
+            }
+        },
+    };
+    modalManager.open(AppUpdateAvailableModal, props);
+}
+function runUninstall(_ctx) {
+    var _a, _b;
+    const ref = readSelection();
+    if (!ref)
+        return;
+    const { appId } = ref;
+    const installed = storeContext.state.ephemeral.installed.find((p) => p.id === appId);
+    if (!installed)
+        return;
+    const label = (_b = (_a = findApp(appId)) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : appId;
+    const props = {
+        appId,
+        appLabel: label,
+        version: installed.version,
+        onConfirm: async () => {
+            try {
+                await storeContext.uninstallPackage(appId);
+                toastManager.notify(`Uninstalled ${label}`, { level: 'success' });
+            }
+            catch (e) {
+                toastManager.notify(`Uninstall failed: ${e.message}`, { level: 'error', duration: 5000 });
+                throw e;
+            }
+        },
+    };
+    modalManager.open(UninstallAppDialog, props);
+}
+/**
+ * Register the three element-scope app actions on the given shard context.
+ * Returns a disposer that unregisters all three (the framework expects the
+ * shard's activate to keep the disposers alive across deactivate).
+ */
+export function registerAppActions(ctx) {
+    const infoLabel = () => {
+        const ref = readSelection();
+        if (!ref)
+            return '';
+        const m = findApp(ref.appId);
+        if (!m)
+            return ref.appId;
+        return `${m.id} v${m.version}`;
+    };
+    const updateLabel = () => {
+        const ref = readSelection();
+        if (!ref)
+            return 'Check for updates';
+        return `Check for updates${computeAppActionLabelSuffix(gateFor(ref.appId))}`;
+    };
+    const uninstallLabel = () => {
+        const ref = readSelection();
+        if (!ref)
+            return 'Uninstall…';
+        return `Uninstall…${computeAppActionLabelSuffix(gateFor(ref.appId))}`;
+    };
+    const isDisabledForCurrent = () => {
+        const ref = readSelection();
+        if (!ref)
+            return true;
+        return computeAppActionDisabled(gateFor(ref.appId));
+    };
+    const actions = [
+        {
+            id: 'app.info',
+            label: infoLabel,
+            scope: { element: 'app' },
+            contextItem: true,
+            group: 'info',
+            disabled: true,
+        },
+        {
+            id: 'app.checkUpdate',
+            label: updateLabel,
+            scope: { element: 'app' },
+            contextItem: true,
+            group: 'update',
+            disabled: isDisabledForCurrent,
+            run: runCheckUpdate,
+        },
+        {
+            id: 'app.uninstall',
+            label: uninstallLabel,
+            scope: { element: 'app' },
+            contextItem: true,
+            group: 'uninstall',
+            disabled: isDisabledForCurrent,
+            run: runUninstall,
+        },
+    ];
+    const disposers = actions.map((a) => ctx.actions.register(a));
+    return () => disposers.forEach((d) => d());
+}