sh3-core 0.1.0 → 0.2.0

package/dist/auth/auth.svelte.d.ts

@@ -37,6 +37,12 @@ export declare function deescalate(): void;
  * Reactive getter — true when the user has elevated to admin mode.
  */
 export declare function isAdmin(): boolean;
+/**
+ * Mark this session as local-owner — auto-elevate to admin without
+ * key verification. Called by the host in Tauri / dev environments
+ * where the user owns the machine. Idempotent.
+ */
+export declare function setLocalOwner(): void;
 /**
  * Build an Authorization header value for authenticated fetch calls.
  * Returns null if not elevated.

package/dist/auth/auth.svelte.js

@@ -109,6 +109,14 @@ export function deescalate() {
 export function isAdmin() {
     return admin;
 }
+/**
+ * Mark this session as local-owner — auto-elevate to admin without
+ * key verification. Called by the host in Tauri / dev environments
+ * where the user owns the machine. Idempotent.
+ */
+export function setLocalOwner() {
+    admin = true;
+}
 /**
  * Build an Authorization header value for authenticated fetch calls.
  * Returns null if not elevated.

package/dist/auth/index.d.ts

@@ -1 +1 @@
-export { initAuth, elevate, deescalate, isAdmin, getAuthHeader } from './auth.svelte';
+export { initAuth, elevate, deescalate, isAdmin, getAuthHeader, setLocalOwner } from './auth.svelte';

package/dist/auth/index.js

@@ -1 +1 @@
-export { initAuth, elevate, deescalate, isAdmin, getAuthHeader } from './auth.svelte';
+export { initAuth, elevate, deescalate, isAdmin, getAuthHeader, setLocalOwner } from './auth.svelte';

package/dist/createShell.d.ts

@@ -0,0 +1,31 @@
+import type { Shard, App } from './index';
+export interface ShellConfig {
+    /** Framework shard IDs to exclude (all included by default) */
+    excludeShards?: string[];
+    /** Framework app IDs to exclude (all included by default) */
+    excludeApps?: string[];
+    /** Additional shards to register */
+    shards?: Shard[];
+    /** Additional apps to register */
+    apps?: App[];
+    /**
+     * Packages to pre-install at boot if not already present in IndexedDB.
+     * Used for environments that ship certain packages out of the box
+     * (e.g. a registry host pre-includes sh3-registry).
+     */
+    preinstall?: Array<{
+        /** Path to the client bundle file (relative to host root or absolute URL). */
+        path: string;
+        /** Path to the server bundle file (optional, for shards with server counterparts). */
+        serverPath?: string;
+        /** Package metadata for the install record. */
+        meta: {
+            id: string;
+            type: 'shard' | 'app';
+            version: string;
+        };
+    }>;
+    /** Mount target — CSS selector or element (defaults to '#app') */
+    target?: string | HTMLElement;
+}
+export declare function createShell(config?: ShellConfig): Promise<void>;

package/dist/createShell.js

@@ -0,0 +1,109 @@
+/*
+ * createShell — public factory for booting an SH3 shell.
+ *
+ * Consumers call this from their own main.ts instead of manually
+ * importing registerShard / registerApp / bootstrap / Shell. The
+ * factory handles platform detection, registration, bootstrap, and
+ * mounting in the correct order.
+ */
+import { mount } from 'svelte';
+import { Shell } from './index';
+import { registerShard, registerApp, bootstrap, __setBackend, setLocalOwner, installPackage, listInstalledPackages, } from './host';
+import { resolvePlatform } from './platform/index';
+export async function createShell(config) {
+    var _a, _b;
+    // 1. Platform detection — must run before bootstrap so state zones
+    //    hydrate from the right backend, and local-owner environments
+    //    auto-elevate to admin.
+    const platform = await resolvePlatform();
+    if (platform.backends) {
+        __setBackend('workspace', platform.backends.workspace);
+        __setBackend('user', platform.backends.user);
+    }
+    if (platform.localOwner) {
+        setLocalOwner();
+    }
+    // 1b. Pre-install packages that this host ships out of the box.
+    if ((_a = config === null || config === void 0 ? void 0 : config.preinstall) === null || _a === void 0 ? void 0 : _a.length) {
+        const installed = await listInstalledPackages();
+        const installedIds = new Set(installed.map((p) => p.id));
+        for (const pkg of config.preinstall) {
+            if (installedIds.has(pkg.meta.id))
+                continue;
+            try {
+                const res = await fetch(pkg.path);
+                if (!res.ok) {
+                    console.warn(`[sh3] Pre-install fetch failed for "${pkg.meta.id}": HTTP ${res.status}`);
+                    continue;
+                }
+                const bundle = await res.arrayBuffer();
+                const result = await installPackage(bundle, {
+                    id: pkg.meta.id,
+                    type: pkg.meta.type,
+                    version: pkg.meta.version,
+                    contractVersion: '1',
+                    sourceRegistry: 'local',
+                    integrity: '',
+                    hasServerBundle: !!pkg.serverPath,
+                });
+                if (!result.success) {
+                    console.warn(`[sh3] Pre-install failed for "${pkg.meta.id}":`, result.error);
+                    continue;
+                }
+                // Push server bundle if present
+                if (pkg.serverPath) {
+                    try {
+                        const serverRes = await fetch(pkg.serverPath);
+                        if (serverRes.ok) {
+                            const serverBytes = await serverRes.arrayBuffer();
+                            const form = new FormData();
+                            form.append('shardId', pkg.meta.id);
+                            form.append('bundle', new Blob([serverBytes], { type: 'application/javascript' }), 'bundle.js');
+                            form.append('manifest', JSON.stringify(pkg.meta));
+                            await fetch('/api/server-shards/install', {
+                                method: 'POST',
+                                body: form,
+                            });
+                        }
+                    }
+                    catch (_c) {
+                        console.warn(`[sh3] Server bundle push failed for pre-install "${pkg.meta.id}"`);
+                    }
+                }
+                console.log(`[sh3] Pre-installed: ${pkg.meta.id}`);
+            }
+            catch (err) {
+                console.warn(`[sh3] Pre-install error for "${pkg.meta.id}":`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+    // 2. Register consumer-provided shards and apps. These go in before
+    //    bootstrap() so they appear in registeredShards, but framework
+    //    shards activate first (insertion-order guarantee in bootstrap).
+    if (config === null || config === void 0 ? void 0 : config.shards) {
+        for (const shard of config.shards) {
+            registerShard(shard);
+        }
+    }
+    if (config === null || config === void 0 ? void 0 : config.apps) {
+        for (const app of config.apps) {
+            registerApp(app);
+        }
+    }
+    // 3. Bootstrap — framework shards/apps registered internally,
+    //    filtered by the exclude lists.
+    const bootstrapConfig = {};
+    if (config === null || config === void 0 ? void 0 : config.excludeShards)
+        bootstrapConfig.excludeShards = config.excludeShards;
+    if (config === null || config === void 0 ? void 0 : config.excludeApps)
+        bootstrapConfig.excludeApps = config.excludeApps;
+    await bootstrap(bootstrapConfig);
+    // 4. Mount the shell.
+    const target = typeof (config === null || config === void 0 ? void 0 : config.target) === 'string'
+        ? document.querySelector(config.target)
+        : (_b = config === null || config === void 0 ? void 0 : config.target) !== null && _b !== void 0 ? _b : document.getElementById('app');
+    if (!target) {
+        throw new Error('SH3: mount target not found');
+    }
+    mount(Shell, { target });
+}

package/dist/diagnostic/DiagnosticPanel.svelte

@@ -0,0 +1,106 @@
+<script lang="ts">
+  /*
+   * Diagnostic panel — framework introspection view.
+   *
+   * Shows:
+   *   - Registered shards (id, version, view count)
+   *   - Active shards (id)
+   *   - Active app (id) or "none"
+   *   - Active layout source (home vs app)
+   *
+   * Reads through the public sh3 API surface only.
+   */
+
+  import {
+    listRegisteredApps,
+    getActiveApp,
+    inspectActiveLayout,
+    registeredShards,
+    activeShards,
+  } from '../api';
+
+  const apps = $derived(listRegisteredApps());
+  const active = $derived(getActiveApp());
+  const layout = $derived(inspectActiveLayout());
+  const regShards = $derived(Array.from(registeredShards.values()));
+  const actShards = $derived(Array.from(activeShards.keys()));
+</script>
+
+<div class="diagnostic">
+  <h2>Diagnostic</h2>
+
+  <section>
+    <h3>Active app</h3>
+    <p>{active ? `${active.label} (${active.id})` : 'none'}</p>
+  </section>
+
+  <section>
+    <h3>Layout source</h3>
+    <p>{layout.source}</p>
+  </section>
+
+  <section>
+    <h3>Registered shards ({regShards.length})</h3>
+    <ul>
+      {#each regShards as shard (shard.manifest.id)}
+        <li>
+          {shard.manifest.label} — {shard.manifest.id} — v{shard.manifest.version}
+          — {shard.manifest.views.length} views
+        </li>
+      {/each}
+    </ul>
+  </section>
+
+  <section>
+    <h3>Active shards ({actShards.length})</h3>
+    <ul>
+      {#each actShards as id (id)}
+        <li>{id}</li>
+      {/each}
+    </ul>
+  </section>
+
+  <section>
+    <h3>Registered apps ({apps.length})</h3>
+    <ul>
+      {#each apps as manifest (manifest.id)}
+        <li>{manifest.label} — {manifest.id} — v{manifest.version}</li>
+      {/each}
+    </ul>
+  </section>
+</div>
+
+<style>
+  .diagnostic {
+    position: absolute;
+    inset: 0;
+    padding: 12px 16px;
+    overflow: auto;
+    background: var(--shell-bg);
+    color: var(--shell-fg);
+    font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+    font-size: 12px;
+  }
+  h2 {
+    margin: 0 0 12px;
+    color: var(--shell-accent);
+    font-size: 14px;
+  }
+  h3 {
+    margin: 12px 0 4px;
+    color: var(--shell-fg-muted);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+  }
+  p, li {
+    margin: 0;
+  }
+  ul {
+    margin: 0;
+    padding-left: 16px;
+  }
+  section {
+    margin-bottom: 8px;
+  }
+</style>

package/dist/diagnostic/DiagnosticPanel.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const DiagnosticPanel: import("svelte").Component<Record<string, never>, {}, "">;
+type DiagnosticPanel = ReturnType<typeof DiagnosticPanel>;
+export default DiagnosticPanel;

package/dist/diagnostic/DiagnosticPromptModal.svelte

@@ -0,0 +1,82 @@
+<script lang="ts">
+  /*
+   * DiagnosticPromptModal — first-time prompt asking the user whether the
+   * diagnostic panel should dock into the current app's layout or stay
+   * silent for this session. The choice is persisted per-app-id in the
+   * diagnostic shard's workspace zone.
+   *
+   * Props:
+   *   - appLabel: human label of the active app (for the prompt text)
+   *   - onChoose: callback invoked with the user's choice; also responsible
+   *     for any side effects (persist + dock). We call `close()` right
+   *     after so the modal tears down regardless.
+   *
+   * The `close` prop is injected by the modal manager (see overlays/modal.ts).
+   */
+
+  let {
+    appLabel,
+    onChoose,
+    close,
+  }: {
+    appLabel: string;
+    onChoose: (choice: 'dock' | 'silent') => void;
+    close: () => void;
+  } = $props();
+
+  function pick(choice: 'dock' | 'silent') {
+    onChoose(choice);
+    close();
+  }
+</script>
+
+<div class="body">
+  <h2>Diagnostic shard</h2>
+  <p>
+    Dock the diagnostic panel into <strong>{appLabel}</strong>'s layout,
+    or keep it silent for this session? Your choice is remembered per app.
+  </p>
+  <div class="row">
+    <button type="button" onclick={() => pick('dock')}>Dock</button>
+    <button type="button" class="secondary" onclick={() => pick('silent')}>Silent</button>
+  </div>
+</div>
+
+<style>
+  .body {
+    padding: var(--shell-pad-lg);
+    display: flex;
+    flex-direction: column;
+    gap: var(--shell-pad-md);
+    min-width: 320px;
+  }
+  h2 {
+    margin: 0;
+    font-size: 16px;
+    color: var(--shell-fg);
+  }
+  p {
+    margin: 0;
+    color: var(--shell-fg-muted);
+    font-size: 13px;
+    line-height: 1.5;
+  }
+  .row {
+    display: flex;
+    gap: var(--shell-pad-sm);
+  }
+  button {
+    appearance: none;
+    font: inherit;
+    font-size: 12px;
+    padding: var(--shell-pad-sm) var(--shell-pad-md);
+    background: var(--shell-accent-muted);
+    color: var(--shell-fg);
+    border: 1px solid var(--shell-border-strong);
+    border-radius: 3px;
+    cursor: pointer;
+  }
+  button:hover { background: var(--shell-accent); }
+  button.secondary { background: transparent; }
+  button.secondary:hover { background: var(--shell-bg-sunken); }
+</style>

package/dist/diagnostic/DiagnosticPromptModal.svelte.d.ts

@@ -0,0 +1,8 @@
+type $$ComponentProps = {
+    appLabel: string;
+    onChoose: (choice: 'dock' | 'silent') => void;
+    close: () => void;
+};
+declare const DiagnosticPromptModal: import("svelte").Component<$$ComponentProps, {}, "">;
+type DiagnosticPromptModal = ReturnType<typeof DiagnosticPromptModal>;
+export default DiagnosticPromptModal;

package/dist/diagnostic/diagnosticApp.d.ts

@@ -0,0 +1,2 @@
+import type { App } from '../apps/types';
+export declare const diagnosticApp: App;

package/dist/diagnostic/diagnosticApp.js

@@ -0,0 +1,24 @@
+/*
+ * Diagnostic app — framework-shipped introspection app.
+ *
+ * Provides a launchable app from the home screen that opens the
+ * diagnostic panel in a single-tab layout. Unlike the shard's
+ * autostart dock behavior (which splices into other apps), this
+ * gives the diagnostic view its own dedicated workspace.
+ */
+export const diagnosticApp = {
+    manifest: {
+        id: 'diagnostic-app',
+        label: 'Diagnostic',
+        version: '0.1.0',
+        requiredShards: ['diagnostic'],
+        layoutVersion: 1,
+    },
+    initialLayout: {
+        type: 'tabs',
+        activeTab: 0,
+        tabs: [
+            { slotId: 'diagnostic.main', viewId: 'diagnostic:panel', label: 'Diagnostic' },
+        ],
+    },
+};

package/dist/diagnostic/diagnosticShard.svelte.d.ts

@@ -0,0 +1,2 @@
+import type { Shard } from '../api';
+export declare const diagnosticShard: Shard;

package/dist/diagnostic/diagnosticShard.svelte.js

@@ -0,0 +1,106 @@
+/*
+ * Diagnostic shard — self-driving framework introspection shard.
+ *
+ * Always loaded in phase 8 (no env split yet). Self-starts via its
+ * `autostart` hook:
+ *   - If the shell is on home at boot: silently attempt to splice a
+ *     diagnostic panel into home's layout. Home is a single-slot layout
+ *     in phase 8, so this gracefully no-ops when no tabs group is found.
+ *   - If an app is active: read own workspace zone for a per-app
+ *     `sessionBehavior` preference. If 'silent', do nothing. If 'dock',
+ *     attempt dock. If unset, open a modal asking "Dock" vs "Silent".
+ *     Persist the choice and act on it.
+ *
+ * Note on internal imports: DiagnosticPanel.svelte reads from
+ * `shards/activate.svelte.ts` directly for the registeredShards /
+ * activeShards reactive maps. That's a deliberate phase-8 shortcut —
+ * introspection helpers belong on the public api.ts surface long-term,
+ * but factoring them out is a phase-9 concern.
+ *
+ * Note on the modal path: in phase 8 all shards load at boot, so
+ * autostart runs while the shell is on home. The per-app modal prompt
+ * path is therefore effectively dead code in phase 8 (it would only be
+ * reachable if diagnostic were activated mid-session after an app had
+ * launched). Included for design completeness.
+ */
+import { mount, unmount } from 'svelte';
+import DiagnosticPanel from './DiagnosticPanel.svelte';
+import DiagnosticPromptModal from './DiagnosticPromptModal.svelte';
+import { shell, getActiveApp, spliceIntoActiveLayout, inspectActiveLayout, } from '../api';
+export const diagnosticShard = {
+    manifest: {
+        id: 'diagnostic',
+        label: 'Diagnostic',
+        version: '0.1.0',
+        views: [{ id: 'diagnostic:panel', label: 'Diagnostic' }],
+    },
+    activate(ctx) {
+        const factory = {
+            mount(container, _context) {
+                const instance = mount(DiagnosticPanel, { target: container });
+                return {
+                    unmount() {
+                        unmount(instance);
+                    },
+                };
+            },
+        };
+        ctx.registerView('diagnostic:panel', factory);
+    },
+    autostart(ctx) {
+        const state = ctx.state({
+            workspace: {
+                sessionBehavior: {},
+            },
+        });
+        const active = getActiveApp();
+        // Home context: attempt a silent dock. Home's single-slot layout has
+        // no tabs group in phase 8 so tryDock will no-op gracefully.
+        if (!active) {
+            tryDock();
+            return;
+        }
+        const contextKey = active.id;
+        const stored = state.workspace.sessionBehavior[contextKey];
+        if (stored === 'silent')
+            return;
+        if (stored === 'dock') {
+            tryDock();
+            return;
+        }
+        // First-time prompt for this app.
+        shell.modal.open(DiagnosticPromptModal, {
+            appLabel: active.label,
+            onChoose: (choice) => {
+                state.workspace.sessionBehavior[contextKey] = choice;
+                if (choice === 'dock')
+                    tryDock();
+            },
+        });
+    },
+};
+function tryDock() {
+    const { root } = inspectActiveLayout();
+    if (!containsTabs(root))
+        return;
+    try {
+        spliceIntoActiveLayout({
+            slotId: 'diagnostic.panel',
+            viewId: 'diagnostic:panel',
+            label: 'Diagnostic',
+        });
+    }
+    catch (err) {
+        // Splice can still refuse for reasons the containsTabs probe doesn't
+        // cover (e.g. a layout shape the helper doesn't accept). Failing
+        // silently is the right call for a self-starting introspection shard.
+        console.warn('[diagnostic] splice failed:', err);
+    }
+}
+function containsTabs(node) {
+    if (node.type === 'tabs')
+        return true;
+    if (node.type === 'split')
+        return node.children.some((c) => containsTabs(c));
+    return false;
+}

package/dist/host-entry.d.ts

@@ -1,4 +1,5 @@
-export { registerShard, registerApp, bootstrap, __setBackend } from './host';
+export { registerShard, registerApp, bootstrap, __setBackend, setLocalOwner } from './host';
+export type { BootstrapConfig } from './host';
 export { __setTenantId, __setDocumentBackend } from './host';
 export type { Backend } from './state/types';
 export type { DocumentBackend } from './documents/types';
@@ -7,3 +8,5 @@ export { installPackage, uninstallPackage, listInstalledPackages, loadInstalledP
 export type { InstalledPackage, InstallResult, PackageMeta } from './registry/types';
 export { initAuth, elevate, deescalate } from './auth/index';
 export { adminAppIds } from './host';
+export { createShell } from './createShell';
+export type { ShellConfig } from './createShell';

package/dist/host-entry.js

@@ -5,7 +5,7 @@
  * boots an SH3 shell (a main.ts that mounts Shell and registers shards/apps)
  * should touch this path. Shards and apps must not import from here.
  */
-export { registerShard, registerApp, bootstrap, __setBackend } from './host';
+export { registerShard, registerApp, bootstrap, __setBackend, setLocalOwner } from './host';
 export { __setTenantId, __setDocumentBackend } from './host';
 export { HttpDocumentBackend } from './documents/http-backend';
 // Install API (host-only).
@@ -13,3 +13,5 @@ export { installPackage, uninstallPackage, listInstalledPackages, loadInstalledP
 // Admin mode (host-only — elevate/deescalate drive the shell UI, initAuth runs at boot).
 export { initAuth, elevate, deescalate } from './auth/index';
 export { adminAppIds } from './host';
+// Shell boot factory.
+export { createShell } from './createShell';

package/dist/host.d.ts

@@ -1,13 +1,22 @@
 import { registerShard as registerShardInternal } from './shards/activate.svelte';
 import { registerApp } from './apps/registry.svelte';
 import { __setBackend } from './state/zones.svelte';
+import { setLocalOwner } from './auth/index';
 export { __setBackend };
+export { setLocalOwner };
 export { __setTenantId, __setDocumentBackend } from './documents/config';
 export declare function registerShard(shard: Parameters<typeof registerShardInternal>[0]): void;
 export { registerApp };
-export declare function bootstrap(): Promise<void>;
+export interface BootstrapConfig {
+    /** Framework shard IDs to skip registration for */
+    excludeShards?: string[];
+    /** Framework app IDs to skip registration for */
+    excludeApps?: string[];
+}
+export declare function bootstrap(config?: BootstrapConfig): Promise<void>;
 /**
  * Set of app IDs that require admin mode. Framework-internal — used by
  * the shell home to gate visibility. Not part of the app contract.
  */
 export declare const adminAppIds: ReadonlySet<string>;
+export { installPackage, listInstalledPackages } from './registry/installer';

package/dist/host.js

@@ -3,13 +3,13 @@
  *
  * Registration APIs (`registerShard`, `registerApp`) are data-only and
  * safe to call at any time; a future runtime loader uses them identically
- * to the boot-time glob loop.
+ * to hot-install registration at runtime.
  *
  * `bootstrap()` runs the post-registration boot sequence: it registers
- * the framework-owned __shell__ pseudo-shard, walks the registered-shards
- * map and activates every self-starting shard, then reads the last-app
- * user-zone entry and either launches that app or leaves the shell on
- * home.
+ * framework-owned shards and apps (filtering any the host excludes via
+ * BootstrapConfig), walks the registered-shards map and activates every
+ * self-starting shard, then reads the last-app user-zone entry and
+ * either launches that app or leaves the shell on home.
  *
  * This file is intentionally NOT re-exported through `api.ts`. The
  * import-hygiene rule is: shards and apps import from `api.ts`, the host
@@ -22,30 +22,41 @@ import { shellShard } from './shell-shard/shellShard.svelte';
 import { storeShard } from './store/storeShard.svelte';
 import { __setBackend } from './state/zones.svelte';
 import { loadInstalledPackages } from './registry/installer';
-import { initAuth } from './auth/index';
+import { initAuth, isAdmin, setLocalOwner } from './auth/index';
 import { storeApp } from './store/storeApp';
-import { registryShard } from './registry-shard/registryShard.svelte';
-import { registryApp } from './registry-shard/registryApp';
+import { diagnosticShard } from './diagnostic/diagnosticShard.svelte';
+import { diagnosticApp } from './diagnostic/diagnosticApp';
 export { __setBackend };
+export { setLocalOwner };
 export { __setTenantId, __setDocumentBackend } from './documents/config';
 export function registerShard(shard) {
     registerShardInternal(shard);
 }
 export { registerApp };
-export async function bootstrap() {
-    // 1. Framework-owned shards are registered first — before installed
-    //    packages — so that a malicious installed package cannot claim a
-    //    reserved id like __shell__ or sh3-store.
-    registerShardInternal(shellShard);
-    registerShardInternal(storeShard);
-    registerShardInternal(registryShard);
+export async function bootstrap(config) {
+    const exShards = new Set(config === null || config === void 0 ? void 0 : config.excludeShards);
+    const exApps = new Set(config === null || config === void 0 ? void 0 : config.excludeApps);
+    // 1. Framework-owned shards — registered first so installed packages
+    //    cannot claim reserved IDs like __shell__ or sh3-store.
+    const frameworkShards = [shellShard, storeShard, diagnosticShard];
+    for (const shard of frameworkShards) {
+        if (!exShards.has(shard.manifest.id)) {
+            registerShardInternal(shard);
+        }
+    }
     // 2. Framework-shipped admin apps.
-    registerApp(storeApp);
-    registerApp(registryApp);
-    // 3. Verify stored admin key (if any) against the server. Uses a
-    //    3-second timeout and fails open — the shell boots without admin
-    //    access if the server is slow or offline.
-    await initAuth();
+    const frameworkApps = [storeApp, diagnosticApp];
+    for (const app of frameworkApps) {
+        if (!exApps.has(app.manifest.id)) {
+            registerApp(app);
+        }
+    }
+    // 3. Auth — if the host already called setLocalOwner() (Tauri / dev),
+    //    skip server verification. Otherwise verify the stored admin key
+    //    against the server (3s timeout, fails open).
+    if (!isAdmin()) {
+        await initAuth();
+    }
     // 4. Load any packages that were hot-installed in a previous session
     //    from IndexedDB. Runs after framework shards but before activation
     //    so installed packages participate in the self-starting pass.
@@ -70,4 +81,5 @@ export async function bootstrap() {
  * Set of app IDs that require admin mode. Framework-internal — used by
  * the shell home to gate visibility. Not part of the app contract.
  */
-export const adminAppIds = new Set(['sh3-store-app', 'sh3-registry-app']);
+export const adminAppIds = new Set(['sh3-store-app', 'diagnostic-app']);
+export { installPackage, listInstalledPackages } from './registry/installer';