sh3-core 0.6.0

package/dist/primitives/TabbedPanel.svelte

@@ -0,0 +1,305 @@
+<script lang="ts" module>
+  /**
+   * Controller plugged in by a layout-aware parent to turn tab drags
+   * into layout mutations. The primitive itself is layout-agnostic:
+   * it just calls `onPointerDown` when a tab is grabbed, and asks the
+   * controller to hit-test the strip during a drag via `onStripHover`.
+   */
+  export interface TabDragController {
+    onPointerDown(index: number, event: PointerEvent, element: HTMLElement): void;
+    onStripHover(
+      stripRect: DOMRect,
+      pointerX: number,
+      pointerY: number,
+      tabRects: DOMRect[],
+    ): number | null;
+    onStripLeave(): void;
+    readonly isDragging: boolean;
+  }
+
+  /**
+   * Pure helper: given an insert index and the tab button rects,
+   * compute the indicator's position in strip-local coordinates.
+   */
+  export function computeIndicatorRect(
+    insertIndex: number,
+    tabEls: (HTMLButtonElement | undefined)[],
+    stripEl: HTMLDivElement | undefined,
+  ): { left: number; top: number; height: number } | null {
+    if (!stripEl) return null;
+    const stripRect = stripEl.getBoundingClientRect();
+    const els = tabEls.filter((el): el is HTMLButtonElement => !!el);
+    if (els.length === 0) {
+      return { left: 4, top: 2, height: stripRect.height - 4 };
+    }
+    const clamped = Math.max(0, Math.min(insertIndex, els.length));
+    let leftViewport: number;
+    if (clamped === els.length) {
+      const last = els[els.length - 1].getBoundingClientRect();
+      leftViewport = last.right;
+    } else {
+      const at = els[clamped].getBoundingClientRect();
+      leftViewport = at.left;
+    }
+    return {
+      left: leftViewport - stripRect.left - 1,
+      top: 2,
+      height: stripRect.height - 4,
+    };
+  }
+</script>
+
+<script lang="ts">
+  /*
+   * TabbedPanel — a tab strip over a single active body.
+   *
+   * Scope: render a strip of tab labels, click to switch active tab,
+   * render every tab's body (hiding inactive ones via `display: none`).
+   * If a `dragController` is provided, tab pointerdown starts a drag
+   * and the strip becomes a drop zone with an insertion indicator.
+   *
+   * All body snippets are rendered concurrently so every tab's
+   * SlotContainer stays alive while the tab is inactive. The
+   * re-parenting contract relies on this — see slotHostPool.ts.
+   */
+
+  import type { Snippet } from 'svelte';
+
+  let {
+    labels,
+    icons,
+    body,
+    activeTab,
+    onActiveChange,
+    dragController,
+    clickGuard,
+    closable,
+    dirty,
+    onClose,
+  }: {
+    labels: string[];
+    icons?: (string | undefined)[];
+    /** Snippet invoked once per tab with its index. */
+    body: Snippet<[number]>;
+    activeTab: number;
+    /** Called when the user picks a different tab. The parent is
+     *  expected to write the new value back into whatever it is
+     *  storing activeTab in. We use a callback rather than a
+     *  $bindable prop because the parent's activeTab typically lives
+     *  inside a larger $state object (a LayoutNode), and `bind:` on a
+     *  sub-property trips Svelte 5's ownership warning. */
+    onActiveChange?: (index: number) => void;
+    dragController?: TabDragController;
+    /** Optional: called by the tab click handler; if it returns true,
+     *  the click is ignored. Used to swallow the synthetic click that
+     *  fires on the source tab after a drag commit. */
+    clickGuard?: () => boolean;
+    /** Per-tab closability. True if the tab can be closed. */
+    closable?: (boolean | undefined)[];
+    /** Per-tab dirty state. True if the tab has unsaved changes. */
+    dirty?: (boolean | undefined)[];
+    /** Called when the user clicks a tab's close button. */
+    onClose?: (index: number) => void;
+  } = $props();
+
+  function select(i: number) {
+    if (clickGuard?.()) return;
+    onActiveChange?.(i);
+  }
+
+  function handleClose(i: number, e: Event) {
+    e.stopPropagation(); // Don't also trigger tab selection.
+    onClose?.(i);
+  }
+
+  let stripEl: HTMLDivElement | undefined = $state();
+  const tabEls: (HTMLButtonElement | undefined)[] = $state([]);
+  let hoverInsertIndex: number | null = $state(null);
+
+  function onTabPointerDown(i: number, e: PointerEvent) {
+    if (!dragController) return;
+    const el = tabEls[i];
+    if (!el) return;
+    dragController.onPointerDown(i, e, el);
+  }
+
+  function onStripPointerMove(e: PointerEvent) {
+    if (!dragController || !dragController.isDragging || !stripEl) return;
+    const stripRect = stripEl.getBoundingClientRect();
+    const rects = tabEls
+      .filter((el): el is HTMLButtonElement => !!el)
+      .map((el) => el.getBoundingClientRect());
+    hoverInsertIndex = dragController.onStripHover(stripRect, e.clientX, e.clientY, rects);
+  }
+
+  function onStripPointerLeave() {
+    if (!dragController) return;
+    hoverInsertIndex = null;
+    dragController.onStripLeave();
+  }
+</script>
+
+<div class="tabbed-panel">
+  <!-- svelte-ignore a11y_no_static_element_interactions -->
+  <div
+    class="tab-strip"
+    role="tablist"
+    tabindex="-1"
+    bind:this={stripEl}
+    onpointermove={onStripPointerMove}
+    onpointerleave={onStripPointerLeave}
+  >
+    {#each labels as label, i (i)}
+      <button
+        type="button"
+        class="tab"
+        class:active={activeTab === i}
+        role="tab"
+        aria-selected={activeTab === i}
+        bind:this={tabEls[i]}
+        onclick={() => select(i)}
+        onpointerdown={(e) => onTabPointerDown(i, e)}
+        onauxclick={(e) => { if (e.button === 1 && closable?.[i]) handleClose(i, e); }}
+      >
+        {#if dirty?.[i]}
+          <span class="tab-dirty" title="Unsaved changes"></span>
+        {/if}
+        {#if icons?.[i]}<span class="tab-icon">{icons[i]}</span>{/if}
+        <span class="tab-label">{label}</span>
+        {#if closable?.[i]}
+          <span
+            class="tab-close"
+            role="button"
+            tabindex="-1"
+            title="Close"
+            onclick={(e) => handleClose(i, e)}
+            onkeydown={(e) => { if (e.key === 'Enter' || e.key === ' ') handleClose(i, e); }}
+          >&#x2715;</span>
+        {/if}
+      </button>
+    {/each}
+    {#if hoverInsertIndex !== null && dragController?.isDragging}
+      {@const rect = computeIndicatorRect(hoverInsertIndex, tabEls, stripEl)}
+      {#if rect}
+        <div
+          class="drop-indicator"
+          style="left: {rect.left}px; height: {rect.height}px; top: {rect.top}px;"
+        ></div>
+      {/if}
+    {/if}
+  </div>
+
+  <div class="tab-body" role="tabpanel">
+    {#each labels as _label, i (i)}
+      <div class="tab-body-pane" class:active={activeTab === i}>
+        {@render body(i)}
+      </div>
+    {/each}
+  </div>
+</div>
+
+<style>
+  .tabbed-panel {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    height: 100%;
+    min-width: 0;
+    min-height: 0;
+    background: var(--shell-grad-bg, var(--shell-bg));
+  }
+
+  .tab-strip {
+    position: relative;
+    flex: 0 0 auto;
+    display: flex;
+    gap: 1px;
+    background: var(--shell-grad-bg-sunken, var(--shell-bg-sunken));
+    border-bottom: 1px solid var(--shell-border);
+    padding: 0 var(--shell-pad-sm);
+    user-select: none;
+  }
+
+  .tab {
+    appearance: none;
+    background: transparent;
+    border: none;
+    color: var(--shell-fg-muted);
+    font: inherit;
+    font-size: 12px;
+    padding: var(--shell-pad-sm) var(--shell-pad-md);
+    margin-top: 2px;
+    display: inline-flex;
+    align-items: center;
+    gap: var(--shell-pad-sm);
+    cursor: pointer;
+    border-top: 2px solid transparent;
+    border-radius: 2px 2px 0 0;
+    /* While dragging we still need pointerdown on tabs, but we want
+       the browser's native drag image suppressed — PointerEvent path
+       doesn't start an HTML5 drag, but preventing text selection here
+       avoids spurious selection rectangles during a drag. */
+    touch-action: none;
+  }
+  .tab:hover {
+    color: var(--shell-fg);
+    background: var(--shell-grad-bg-elevated, var(--shell-bg-elevated));
+  }
+  .tab.active {
+    color: var(--shell-fg);
+    background: var(--shell-grad-bg, var(--shell-bg));
+    border-top-color: var(--shell-accent);
+  }
+  .tab-icon { font-size: 11px; }
+  .tab-label { white-space: nowrap; }
+
+  .tab-dirty {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--shell-accent);
+    flex-shrink: 0;
+  }
+  .tab-close {
+    display: inline-flex;
+    font-size: 10px;
+    line-height: 1;
+    padding: 2px;
+    border-radius: var(--shell-radius-sm);
+    color: var(--shell-fg-muted);
+    cursor: pointer;
+    flex-shrink: 0;
+    margin-left: auto;
+  }
+  .tab-close:hover {
+    color: var(--shell-fg);
+    background: var(--shell-bg-sunken);
+  }
+
+  .drop-indicator {
+    position: absolute;
+    width: 2px;
+    background: var(--shell-accent);
+    box-shadow: 0 0 6px var(--shell-accent);
+    pointer-events: none;
+    border-radius: 1px;
+  }
+
+  .tab-body {
+    flex: 1 1 auto;
+    position: relative;
+    min-width: 0;
+    min-height: 0;
+    overflow: hidden;
+  }
+  .tab-body-pane {
+    position: absolute;
+    inset: 0;
+    min-width: 0;
+    min-height: 0;
+    display: none;
+  }
+  .tab-body-pane.active {
+    display: block;
+  }
+</style>

package/dist/primitives/TabbedPanel.svelte.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Controller plugged in by a layout-aware parent to turn tab drags
+ * into layout mutations. The primitive itself is layout-agnostic:
+ * it just calls `onPointerDown` when a tab is grabbed, and asks the
+ * controller to hit-test the strip during a drag via `onStripHover`.
+ */
+export interface TabDragController {
+    onPointerDown(index: number, event: PointerEvent, element: HTMLElement): void;
+    onStripHover(stripRect: DOMRect, pointerX: number, pointerY: number, tabRects: DOMRect[]): number | null;
+    onStripLeave(): void;
+    readonly isDragging: boolean;
+}
+/**
+ * Pure helper: given an insert index and the tab button rects,
+ * compute the indicator's position in strip-local coordinates.
+ */
+export declare function computeIndicatorRect(insertIndex: number, tabEls: (HTMLButtonElement | undefined)[], stripEl: HTMLDivElement | undefined): {
+    left: number;
+    top: number;
+    height: number;
+} | null;
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    labels: string[];
+    icons?: (string | undefined)[];
+    /** Snippet invoked once per tab with its index. */
+    body: Snippet<[number]>;
+    activeTab: number;
+    /** Called when the user picks a different tab. The parent is
+     *  expected to write the new value back into whatever it is
+     *  storing activeTab in. We use a callback rather than a
+     *  $bindable prop because the parent's activeTab typically lives
+     *  inside a larger $state object (a LayoutNode), and `bind:` on a
+     *  sub-property trips Svelte 5's ownership warning. */
+    onActiveChange?: (index: number) => void;
+    dragController?: TabDragController;
+    /** Optional: called by the tab click handler; if it returns true,
+     *  the click is ignored. Used to swallow the synthetic click that
+     *  fires on the source tab after a drag commit. */
+    clickGuard?: () => boolean;
+    /** Per-tab closability. True if the tab can be closed. */
+    closable?: (boolean | undefined)[];
+    /** Per-tab dirty state. True if the tab has unsaved changes. */
+    dirty?: (boolean | undefined)[];
+    /** Called when the user clicks a tab's close button. */
+    onClose?: (index: number) => void;
+};
+declare const TabbedPanel: import("svelte").Component<$$ComponentProps, {}, "">;
+type TabbedPanel = ReturnType<typeof TabbedPanel>;
+export default TabbedPanel;

package/dist/primitives/base.css

@@ -0,0 +1,42 @@
+/*
+ * SH3 base component styles.
+ *
+ * Shared affordances that sit between tokens (raw values) and components
+ * (full UI). These apply to native elements and the .shell-base-* utility
+ * classes so shards and apps get a consistent look without duplicating
+ * button/input recipes in every component.
+ */
+
+/* ── Buttons ─────────────────────────────────────────────────────────── */
+
+button,
+input[type="button"],
+input[type="submit"],
+input[type="reset"],
+.shell-base-button {
+  padding: 6px 14px;
+  background: var(--shell-accent, #6ea8fe);
+  color: #fff;
+  border: none;
+  border-radius: var(--shell-radius);
+  cursor: pointer;
+  font-family: inherit;
+  font-size: 0.875rem;
+  line-height: var(--shell-line);
+}
+
+button:hover,
+input[type="button"]:hover,
+input[type="submit"]:hover,
+input[type="reset"]:hover,
+.shell-base-button:hover {
+  filter: brightness(1.12);
+}
+
+button:active,
+input[type="button"]:active,
+input[type="submit"]:active,
+input[type="reset"]:active,
+.shell-base-button:active {
+  filter: brightness(0.92);
+}

package/dist/registry/client.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Registry client -- fetches and merges registry indices, resolves
+ * packages, and downloads bundles with integrity verification.
+ *
+ * Typical usage:
+ * ```ts
+ * const packages = await fetchRegistries(['https://example.com/registry.json']);
+ * const pkg = packages.find(p => p.entry.id === 'my-shard');
+ * if (pkg) {
+ *   const data = await fetchBundle(pkg.latest);
+ *   const meta = buildPackageMeta(pkg, pkg.latest);
+ * }
+ * ```
+ */
+import type { PackageEntry, PackageVersion, PackageMeta } from './types.js';
+/**
+ * A `PackageEntry` annotated with its source registry URL and resolved latest version.
+ *
+ * Returned by `fetchRegistries` so callers can display package cards and
+ * initiate installs without needing to re-parse the raw index document.
+ */
+export interface ResolvedPackage {
+    /** The raw package entry from the registry index. */
+    entry: PackageEntry;
+    /**
+     * The latest version of this package.
+     * By convention this is `entry.versions[0]` — registries publish newest-first.
+     */
+    latest: PackageVersion;
+    /** URL of the registry index this package was found in. */
+    sourceRegistry: string;
+}
+/**
+ * Fetch and merge multiple registry indices into a single package catalog.
+ *
+ * Registries are fetched in order. If the same package id appears in more
+ * than one registry, the first registry wins (left-to-right priority).
+ * Fetch or validation failures for individual registries are logged as
+ * warnings and skipped — the function always returns the packages that
+ * could be resolved successfully.
+ *
+ * @param urls - Ordered list of `registry.json` URLs to fetch.
+ * @returns Merged list of resolved packages, deduplicated by package id.
+ */
+export declare function fetchRegistries(urls: string[]): Promise<ResolvedPackage[]>;
+/**
+ * Download a bundle and verify its SRI integrity hash.
+ *
+ * Fetches `version.bundleUrl`, reads the response as an `ArrayBuffer`, then
+ * calls `verifyIntegrity` before returning. Throws on any network error,
+ * non-OK HTTP status, or integrity mismatch — the caller must not execute
+ * a bundle for which this function threw.
+ *
+ * If `bundleUrl` is relative (starts with `/`), it is resolved against
+ * `sourceRegistry` so cross-origin installs hit the correct server.
+ *
+ * @param version - The `PackageVersion` describing the bundle to download.
+ * @param sourceRegistry - The registry URL this package came from (used to resolve relative bundle paths).
+ * @returns Raw bundle bytes, verified against `version.integrity`.
+ * @throws If the fetch fails, the server returns a non-OK status, or the integrity check fails.
+ */
+export declare function fetchBundle(version: PackageVersion, sourceRegistry?: string): Promise<ArrayBuffer>;
+/**
+ * Build a `PackageMeta` record from a resolved package and a chosen version.
+ *
+ * Combines identity fields from the `PackageEntry` with provenance and
+ * integrity fields from the selected `PackageVersion`. The result is passed
+ * to the framework install API alongside the raw bundle bytes.
+ *
+ * @param resolved - The resolved package, as returned by `fetchRegistries`.
+ * @param version - The specific version to install (e.g. `resolved.latest`).
+ * @returns A `PackageMeta` ready to be handed to the install API.
+ */
+export declare function buildPackageMeta(resolved: ResolvedPackage, version: PackageVersion): PackageMeta;

package/dist/registry/client.js

@@ -0,0 +1,117 @@
+/**
+ * Registry client -- fetches and merges registry indices, resolves
+ * packages, and downloads bundles with integrity verification.
+ *
+ * Typical usage:
+ * ```ts
+ * const packages = await fetchRegistries(['https://example.com/registry.json']);
+ * const pkg = packages.find(p => p.entry.id === 'my-shard');
+ * if (pkg) {
+ *   const data = await fetchBundle(pkg.latest);
+ *   const meta = buildPackageMeta(pkg, pkg.latest);
+ * }
+ * ```
+ */
+import { validateRegistryIndex } from './schema.js';
+import { verifyIntegrity } from './integrity.js';
+/**
+ * Fetch and merge multiple registry indices into a single package catalog.
+ *
+ * Registries are fetched in order. If the same package id appears in more
+ * than one registry, the first registry wins (left-to-right priority).
+ * Fetch or validation failures for individual registries are logged as
+ * warnings and skipped — the function always returns the packages that
+ * could be resolved successfully.
+ *
+ * @param urls - Ordered list of `registry.json` URLs to fetch.
+ * @returns Merged list of resolved packages, deduplicated by package id.
+ */
+export async function fetchRegistries(urls) {
+    const seen = new Set();
+    const results = [];
+    for (const url of urls) {
+        let raw;
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                console.warn(`[sh3] Registry fetch failed for ${url}: HTTP ${response.status}`);
+                continue;
+            }
+            raw = await response.json();
+        }
+        catch (err) {
+            console.warn(`[sh3] Registry ${url}: ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
+        let index;
+        try {
+            index = validateRegistryIndex(raw);
+        }
+        catch (err) {
+            console.warn(`[sh3] Registry ${url} failed validation: ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
+        for (const entry of index.packages) {
+            if (seen.has(entry.id))
+                continue;
+            seen.add(entry.id);
+            results.push({
+                entry,
+                latest: entry.versions[0],
+                sourceRegistry: url,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Download a bundle and verify its SRI integrity hash.
+ *
+ * Fetches `version.bundleUrl`, reads the response as an `ArrayBuffer`, then
+ * calls `verifyIntegrity` before returning. Throws on any network error,
+ * non-OK HTTP status, or integrity mismatch — the caller must not execute
+ * a bundle for which this function threw.
+ *
+ * If `bundleUrl` is relative (starts with `/`), it is resolved against
+ * `sourceRegistry` so cross-origin installs hit the correct server.
+ *
+ * @param version - The `PackageVersion` describing the bundle to download.
+ * @param sourceRegistry - The registry URL this package came from (used to resolve relative bundle paths).
+ * @returns Raw bundle bytes, verified against `version.integrity`.
+ * @throws If the fetch fails, the server returns a non-OK status, or the integrity check fails.
+ */
+export async function fetchBundle(version, sourceRegistry) {
+    let url = version.bundleUrl;
+    if (sourceRegistry && !/^https?:\/\//i.test(url)) {
+        url = new URL(url, sourceRegistry).href;
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Bundle fetch failed: HTTP ${response.status} ${response.statusText} from ${url}`);
+    }
+    const data = await response.arrayBuffer();
+    await verifyIntegrity(data, version.integrity);
+    return data;
+}
+/**
+ * Build a `PackageMeta` record from a resolved package and a chosen version.
+ *
+ * Combines identity fields from the `PackageEntry` with provenance and
+ * integrity fields from the selected `PackageVersion`. The result is passed
+ * to the framework install API alongside the raw bundle bytes.
+ *
+ * @param resolved - The resolved package, as returned by `fetchRegistries`.
+ * @param version - The specific version to install (e.g. `resolved.latest`).
+ * @returns A `PackageMeta` ready to be handed to the install API.
+ */
+export function buildPackageMeta(resolved, version) {
+    return {
+        id: resolved.entry.id,
+        type: resolved.entry.type,
+        version: version.version,
+        contractVersion: version.contractVersion,
+        sourceRegistry: resolved.sourceRegistry,
+        integrity: version.integrity,
+        requires: version.requires,
+    };
+}

package/dist/registry/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Registry module barrel export.
+ *
+ * Re-exports the public surface of the registry subsystem: protocol types,
+ * schema validation, integrity verification, client functions, and the
+ * install API.
+ */
+export type { RegistryIndex, PackageEntry, PackageVersion, RequiredDependency, InstalledPackage, InstallResult, PackageMeta, } from './types';
+export { RegistryValidationError, validateRegistryIndex } from './schema';
+export { verifyIntegrity, computeIntegrity } from './integrity';
+export type { ResolvedPackage } from './client';
+export { fetchRegistries, fetchBundle, buildPackageMeta } from './client';
+export { installPackage, uninstallPackage, listInstalledPackages, loadInstalledPackages, } from './installer';

package/dist/registry/index.js

@@ -0,0 +1,14 @@
+/**
+ * Registry module barrel export.
+ *
+ * Re-exports the public surface of the registry subsystem: protocol types,
+ * schema validation, integrity verification, client functions, and the
+ * install API.
+ */
+// Schema validation.
+export { RegistryValidationError, validateRegistryIndex } from './schema';
+// Integrity verification.
+export { verifyIntegrity, computeIntegrity } from './integrity';
+export { fetchRegistries, fetchBundle, buildPackageMeta } from './client';
+// Install API.
+export { installPackage, uninstallPackage, listInstalledPackages, loadInstalledPackages, } from './installer';

package/dist/registry/installer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Package installer -- coordinates storing, loading, and registering packages.
+ *
+ * This is the bridge between the store shard (which fetches and verifies
+ * bundles) and the framework (which registers shards/apps). The install API
+ * is host-only; shards and apps must not import from here.
+ *
+ * Flow:
+ *   1. `installPackage(bundle, meta)` -- load module from bytes, verify
+ *      declared type matches actual type, persist to IndexedDB, register
+ *      with framework.
+ *   2. `uninstallPackage(id)` -- deactivate if active, remove from storage.
+ *   3. `loadInstalledPackages()` -- called at boot, re-loads all installed
+ *      packages from IndexedDB and registers them.
+ */
+import type { InstalledPackage, InstallResult, PackageMeta } from './types';
+/**
+ * Install a package from raw bundle bytes and metadata.
+ *
+ * Loads the ESM module, verifies the declared type matches the actual module
+ * shape, persists to IndexedDB, and registers with the framework. If
+ * registration fails (e.g. duplicate id from a shard that was already
+ * glob-discovered), the package is still persisted but `hotLoaded` is false.
+ *
+ * @param bundle - Raw verified ESM bundle bytes.
+ * @param meta - Provenance metadata for the install record.
+ * @returns Result object indicating success/failure and hot-load status.
+ */
+export declare function installPackage(bundle: ArrayBuffer, meta: PackageMeta): Promise<InstallResult>;
+/**
+ * Uninstall a package by id.
+ *
+ * If the package is a shard and currently active, deactivates it first.
+ * Removes both the bundle and metadata from IndexedDB.
+ *
+ * @param id - The package id to uninstall.
+ */
+export declare function uninstallPackage(id: string): Promise<void>;
+/**
+ * List all installed packages.
+ *
+ * Delegates directly to the storage layer. Returns metadata records only,
+ * not the bundle bytes.
+ */
+export declare function listInstalledPackages(): Promise<InstalledPackage[]>;
+/**
+ * Load all installed packages from IndexedDB and register them.
+ *
+ * Called once at boot by `bootstrap()`, before any glob-discovered shards
+ * or the shell shard are registered. Individual package failures are logged
+ * as warnings but do not prevent the shell from booting.
+ */
+export declare function loadInstalledPackages(): Promise<void>;