sh3-core 0.23.2 → 0.25.0

package/dist/primitives/widgets/DocumentFilePicker.svelte

@@ -1,10 +1,12 @@
-<script lang="ts">
+<script lang="ts" generics="M extends 'open' | 'save'">
   import type { CommitOnlyEvents } from './_contract';
   import { sh3 } from '../../sh3Runtime.svelte';
   import DocumentBrowser from './_DocumentBrowser.svelte';
   import type { DocumentMeta } from '../../documents/types';
   import type { DocEntry, OpenerValue, SaverValue } from './DocumentFilePicker';
 
+  type ValueFor<Mode extends 'open' | 'save'> = Mode extends 'open' ? OpenerValue : SaverValue;
+
   type DocListFn = () => Promise<Array<DocumentMeta & { shardId: string }>>;
   type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
   type HandleFn = {
@@ -17,7 +19,7 @@
 
   let {
     mode,
-    value = $bindable<OpenerValue | SaverValue>(null),
+    value = $bindable<ValueFor<M>>(null as ValueFor<M>),
     listDocuments,
     listFolders,
     handle,
@@ -29,8 +31,8 @@
     selectable = 'file',
     onchange,
   }: {
-    mode: 'open' | 'save';
-    value?: OpenerValue | SaverValue;
+    mode: M;
+    value?: ValueFor<M>;
     listDocuments: DocListFn;
     listFolders?: FolderListFn;
     handle?: HandleFn;
@@ -40,7 +42,7 @@
     size?: 'sm' | 'md';
     buttonLabel?: string;
     selectable?: 'file' | 'folder' | 'both';
-  } & CommitOnlyEvents<OpenerValue | SaverValue> = $props();
+  } & CommitOnlyEvents<ValueFor<M>> = $props();
 
   let trigger = $state<HTMLButtonElement | undefined>(undefined);
   let openFlag = $state(false);
@@ -56,8 +58,8 @@
   );
 
   function handleCommit(result: OpenerValue | SaverValue) {
-    value = result;
-    onchange?.(result);
+    value = result as ValueFor<M>;
+    onchange?.(result as ValueFor<M>);
   }
 
   function onOpenClosed() {

package/dist/primitives/widgets/DocumentFilePicker.svelte.d.ts

@@ -1,32 +1,49 @@
 import type { CommitOnlyEvents } from './_contract';
 import type { DocumentMeta } from '../../documents/types';
 import type { OpenerValue, SaverValue } from './DocumentFilePicker';
-type DocListFn = () => Promise<Array<DocumentMeta & {
-    shardId: string;
-}>>;
-type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
-type HandleFn = {
-    mkdir: (shardId: string, path: string) => Promise<void>;
-    rmdir: (shardId: string, path: string, opts: {
-        recursive: boolean;
-    }) => Promise<void>;
-    renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
-    rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
-    delete: (shardId: string, path: string) => Promise<void>;
+declare function $$render<M extends 'open' | 'save'>(): {
+    props: {
+        mode: M;
+        value?: M extends "open" ? OpenerValue : SaverValue;
+        listDocuments: () => Promise<Array<DocumentMeta & {
+            shardId: string;
+        }>>;
+        listFolders?: (shardId: string, prefix: string) => Promise<string[]>;
+        handle?: {
+            mkdir: (shardId: string, path: string) => Promise<void>;
+            rmdir: (shardId: string, path: string, opts: {
+                recursive: boolean;
+            }) => Promise<void>;
+            renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+            rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+            delete: (shardId: string, path: string) => Promise<void>;
+        };
+        readOnlyShard?: (shardId: string) => boolean;
+        disabled?: boolean;
+        invalid?: boolean;
+        size?: "sm" | "md";
+        buttonLabel?: string;
+        selectable?: "file" | "folder" | "both";
+    } & CommitOnlyEvents<M extends "open" ? OpenerValue : SaverValue>;
+    exports: {};
+    bindings: "value";
+    slots: {};
+    events: {};
 };
-type $$ComponentProps = {
-    mode: 'open' | 'save';
-    value?: OpenerValue | SaverValue;
-    listDocuments: DocListFn;
-    listFolders?: FolderListFn;
-    handle?: HandleFn;
-    readOnlyShard?: (shardId: string) => boolean;
-    disabled?: boolean;
-    invalid?: boolean;
-    size?: 'sm' | 'md';
-    buttonLabel?: string;
-    selectable?: 'file' | 'folder' | 'both';
-} & CommitOnlyEvents<OpenerValue | SaverValue>;
-declare const DocumentFilePicker: import("svelte").Component<$$ComponentProps, {}, "value">;
-type DocumentFilePicker = ReturnType<typeof DocumentFilePicker>;
+declare class __sveltets_Render<M extends 'open' | 'save'> {
+    props(): ReturnType<typeof $$render<M>>['props'];
+    events(): ReturnType<typeof $$render<M>>['events'];
+    slots(): ReturnType<typeof $$render<M>>['slots'];
+    bindings(): "value";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <M extends 'open' | 'save'>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<M>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<M>['props']>, ReturnType<__sveltets_Render<M>['events']>, ReturnType<__sveltets_Render<M>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<M>['bindings']>;
+    } & ReturnType<__sveltets_Render<M>['exports']>;
+    <M extends 'open' | 'save'>(internal: unknown, props: ReturnType<__sveltets_Render<M>['props']> & {}): ReturnType<__sveltets_Render<M>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const DocumentFilePicker: $$IsomorphicComponent;
+type DocumentFilePicker<M extends 'open' | 'save'> = InstanceType<typeof DocumentFilePicker<M>>;
 export default DocumentFilePicker;

package/dist/primitives/widgets/_DocumentBrowser.svelte

@@ -59,7 +59,6 @@
   let selected = $state<Selected>(null);
   let filename = $state(untrack(() => suggestedName));
   let activeIdx = $state(0);
-  let listEl = $state<HTMLElement | undefined>(undefined);
 
   // Folder state loaded via listFolders
   let folders = $state<string[]>([]);
@@ -459,11 +458,12 @@
     </div>
   {/if}
 
-  <div class="sh3-doc-browser__list" bind:this={listEl}>
+  <div class="sh3-doc-browser__list">
     {#if confirmDelete}
-      {@const childCount = confirmDelete.kind === 'folder'
+      {@const folderPath = confirmDelete.kind === 'folder' ? confirmDelete.fullPath : null}
+      {@const childCount = folderPath
         ? docs.filter((d) =>
-            d.shardId === shardId && d.path.startsWith(confirmDelete!.fullPath + '/'),
+            d.shardId === shardId && d.path.startsWith(folderPath + '/'),
           ).length
         : 0}
       <div class="sh3-doc-browser__confirm-overlay">

package/dist/registry/installer.js

@@ -15,8 +15,8 @@
  *      packages from IndexedDB and registers them.
  */
 import { loadBundleModule } from './loader';
-import { savePackage, loadBundle, listInstalled, removePackage } from './storage';
-import { deactivateShard } from '../shards/lifecycle.svelte';
+import { savePackage, loadBundle, loadMeta, listInstalled, removePackage } from './storage';
+import { deactivateShard, unregisterShard } from '../shards/lifecycle.svelte';
 import { unregisterApp } from '../apps/lifecycle';
 import { registerLoadedBundle } from './register';
 import { extractBundlePermissions } from './permission-descriptions';
@@ -35,6 +35,7 @@ import { fetchServerPackages } from '../env/client';
  * @returns Result object indicating success/failure and hot-load status.
  */
 export async function installPackage(bundle, meta, options) {
+    var _a, _b;
     // 1. Load the module from bytes (or reuse the caller's copy).
     // Archive integrity is verified upstream in fetchArchive() before extraction.
     let loaded;
@@ -68,7 +69,33 @@ export async function installPackage(bundle, meta, options) {
             error: `Package "${meta.id}" declared type "app" but bundle contains no valid app`,
         };
     }
-    // 4. Persist to IndexedDB. Permissions captured from manifest(s).
+    // 4. Compute the new bundle's contributed ids. Used both to populate the
+    //    new InstalledPackage record AND to diff against the previous record
+    //    so we can drop shards/apps the new bundle no longer ships.
+    const contributedShards = loaded.shards.map((s) => s.manifest.id);
+    const contributedApps = loaded.apps.map((a) => a.manifest.id);
+    // 5. Diff against the previous record (if any) and unregister anything the
+    //    new bundle no longer ships. Without this, a combo update that drops
+    //    an app leaves the dropped app sitting in `registeredApps` until the
+    //    user clears the webview cache (Bug A).
+    //
+    //    Legacy records written before `contributedShards`/`contributedApps`
+    //    existed treat the missing field as the empty set — no diff is
+    //    possible for that one upgrade, and the fields populate on this save.
+    const prior = await loadMeta(meta.id).catch(() => null);
+    if (prior) {
+        const newShardSet = new Set(contributedShards);
+        const newAppSet = new Set(contributedApps);
+        for (const id of (_a = prior.contributedShards) !== null && _a !== void 0 ? _a : []) {
+            if (!newShardSet.has(id))
+                unregisterShard(id);
+        }
+        for (const id of (_b = prior.contributedApps) !== null && _b !== void 0 ? _b : []) {
+            if (!newAppSet.has(id))
+                unregisterApp(id);
+        }
+    }
+    // 6. Persist to IndexedDB. Permissions captured from manifest(s).
     const record = {
         id: meta.id,
         type: meta.type,
@@ -77,6 +104,8 @@ export async function installPackage(bundle, meta, options) {
         contractVersion: meta.contractVersion,
         installedAt: new Date().toISOString(),
         permissions: extractBundlePermissions(loaded),
+        contributedShards,
+        contributedApps,
     };
     try {
         await savePackage(meta.id, bundle, record);
@@ -88,15 +117,16 @@ export async function installPackage(bundle, meta, options) {
             error: `Failed to persist package: ${err instanceof Error ? err.message : String(err)}`,
         };
     }
-    // 5. Evict any existing registration for this id before re-registering.
-    //    Without this, reinstall at the same version leaks activation state
-    //    (shards stay active) or app entries (apps silently replace but the
-    //    old module instance's module-scope state is never torn down).
+    // 7. Evict any existing registration for the package id itself before
+    //    re-registering. Step 5's diff covers ids the new bundle drops; this
+    //    handles the case where the package id IS one of the new bundle's
+    //    shard/app ids (single-shard or single-app packages) and we need to
+    //    tear down its active state before re-registering the new module.
     if (meta.type === 'shard' || meta.type === 'combo') {
         try {
             deactivateShard(meta.id);
         }
-        catch ( /* not active or not a shard */_a) { /* not active or not a shard */ }
+        catch ( /* not active or not a shard */_c) { /* not active or not a shard */ }
     }
     if (meta.type === 'app' || meta.type === 'combo') {
         unregisterApp(meta.id);
@@ -175,11 +205,21 @@ export async function loadInstalledPackages() {
             await removePackage(pkg.id).catch(() => { });
         }
     }
-    // Load packages from server — use IndexedDB cache if available, else fetch from server
+    // Load packages from server — use IndexedDB cache if available AND the
+    // cached version matches the server's. The server is the source of truth
+    // for installed versions: if another device updated the package, this
+    // device's cache holds a stale bundle and must refetch (Bug B). Without
+    // this, device B opens the env, sees `id` is in local cache, loads the
+    // old bytes, and never notices it's behind.
     for (const serverPkg of serverPackages) {
         if (localIds.has(serverPkg.id)) {
             const localPkg = localPackages.find(p => p.id === serverPkg.id);
-            await _loadFromIndexedDB(localPkg);
+            if (localPkg.version !== serverPkg.version) {
+                await _fetchAndCacheFromServer(serverPkg);
+            }
+            else {
+                await _loadFromIndexedDB(localPkg);
+            }
         }
         else {
             await _fetchAndCacheFromServer(serverPkg);

package/dist/registry/installer.test.d.ts

@@ -0,0 +1 @@
+import 'fake-indexeddb/auto';

package/dist/registry/installer.test.js

@@ -0,0 +1,146 @@
+import 'fake-indexeddb/auto';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { resetFramework } from '../__test__/reset';
+import { makeApp, makeAppManifest, makeShard, makeShardManifest } from '../__test__/fixtures';
+import { installPackage, loadInstalledPackages } from './installer';
+import { savePackage } from './storage';
+import { registeredApps } from '../apps/registry.svelte';
+import { registeredShards } from '../shards/lifecycle.svelte';
+// Mock the network for loadInstalledPackages tests.
+vi.mock('../env/client', () => ({
+    fetchServerPackages: vi.fn(),
+}));
+import { fetchServerPackages } from '../env/client';
+async function wipeIndexedDB() {
+    await new Promise((resolve) => {
+        const req = indexedDB.deleteDatabase('sh3-packages');
+        req.onsuccess = () => resolve();
+        req.onerror = () => resolve();
+        req.onblocked = () => resolve();
+    });
+}
+function makeLoaded(parts = {}) {
+    var _a, _b;
+    return {
+        shards: ((_a = parts.shards) !== null && _a !== void 0 ? _a : []).map((id) => makeShard({ manifest: makeShardManifest({ id }) })),
+        apps: ((_b = parts.apps) !== null && _b !== void 0 ? _b : []).map((id) => makeApp({ manifest: makeAppManifest({ id }) })),
+    };
+}
+function meta(id, type, version) {
+    return { id, type, version, sourceRegistry: '', contractVersion: '1' };
+}
+function installedRecord(id, type, version) {
+    return {
+        id,
+        type,
+        version,
+        sourceRegistry: '',
+        contractVersion: '1',
+        installedAt: '2026-01-01T00:00:00.000Z',
+        permissions: [],
+    };
+}
+// ---------------------------------------------------------------------------
+// Bug A — installPackage must drop apps/shards the new bundle no longer ships
+// ---------------------------------------------------------------------------
+describe('installPackage — diff-based unregistration (Bug A)', () => {
+    beforeEach(async () => {
+        resetFramework();
+        await wipeIndexedDB();
+    });
+    it('unregisters apps from the previous bundle that the new bundle no longer ships', async () => {
+        await installPackage(new ArrayBuffer(0), meta('combo-foo', 'combo', '1.0.0'), {
+            loaded: makeLoaded({ apps: ['bar', 'baz'] }),
+        });
+        expect(registeredApps.has('bar')).toBe(true);
+        expect(registeredApps.has('baz')).toBe(true);
+        await installPackage(new ArrayBuffer(0), meta('combo-foo', 'combo', '1.1.0'), {
+            loaded: makeLoaded({ apps: ['bar'] }),
+        });
+        expect(registeredApps.has('bar')).toBe(true);
+        expect(registeredApps.has('baz')).toBe(false);
+    });
+    it('unregisters shards from the previous bundle that the new bundle no longer ships', async () => {
+        await installPackage(new ArrayBuffer(0), meta('combo-foo', 'combo', '1.0.0'), {
+            loaded: makeLoaded({ shards: ['shard-a', 'shard-b'] }),
+        });
+        expect(registeredShards.has('shard-a')).toBe(true);
+        expect(registeredShards.has('shard-b')).toBe(true);
+        await installPackage(new ArrayBuffer(0), meta('combo-foo', 'combo', '1.1.0'), {
+            loaded: makeLoaded({ shards: ['shard-a'] }),
+        });
+        expect(registeredShards.has('shard-a')).toBe(true);
+        expect(registeredShards.has('shard-b')).toBe(false);
+    });
+    it('preserves entries present in both old and new bundles', async () => {
+        await installPackage(new ArrayBuffer(0), meta('combo-foo', 'combo', '1.0.0'), {
+            loaded: makeLoaded({ shards: ['s1'], apps: ['a1'] }),
+        });
+        await installPackage(new ArrayBuffer(0), meta('combo-foo', 'combo', '1.1.0'), {
+            loaded: makeLoaded({ shards: ['s1'], apps: ['a1'] }),
+        });
+        expect(registeredShards.has('s1')).toBe(true);
+        expect(registeredApps.has('a1')).toBe(true);
+    });
+    it('does not touch unrelated packages on first install of a new package', async () => {
+        await installPackage(new ArrayBuffer(0), meta('pkg-other', 'app', '1.0.0'), {
+            loaded: makeLoaded({ apps: ['other-app'] }),
+        });
+        await installPackage(new ArrayBuffer(0), meta('pkg-new', 'app', '1.0.0'), {
+            loaded: makeLoaded({ apps: ['new-app'] }),
+        });
+        expect(registeredApps.has('other-app')).toBe(true);
+        expect(registeredApps.has('new-app')).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Bug B — loadInstalledPackages must refetch when local version != server
+// ---------------------------------------------------------------------------
+describe('loadInstalledPackages — version reconciliation (Bug B)', () => {
+    beforeEach(async () => {
+        resetFramework();
+        await wipeIndexedDB();
+        vi.resetAllMocks();
+        // Global fetch — used by _fetchAndCacheFromServer.
+        globalThis.fetch = vi.fn();
+        // Silence expected warnings: empty-byte bundles can't be dynamic-imported
+        // in node, so loadBundleModule throws and the installer warns. The
+        // routing decision under test happens before that, so the warnings are
+        // noise we don't want polluting test output.
+        vi.spyOn(console, 'warn').mockImplementation(() => { });
+    });
+    it('refetches from server when local cached version differs from server version', async () => {
+        await savePackage('foo', new ArrayBuffer(0), installedRecord('foo', 'app', '1.0.0'));
+        fetchServerPackages.mockResolvedValue([
+            {
+                id: 'foo',
+                type: 'app',
+                version: '1.1.0',
+                bundleUrl: 'http://server.test/packages/foo/client.js',
+                sourceRegistry: '',
+                contractVersion: '1',
+            },
+        ]);
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: async () => new ArrayBuffer(0),
+        });
+        await loadInstalledPackages();
+        expect(globalThis.fetch).toHaveBeenCalledWith('http://server.test/packages/foo/client.js');
+    });
+    it('uses local cache when local version matches server version', async () => {
+        await savePackage('foo', new ArrayBuffer(0), installedRecord('foo', 'app', '1.0.0'));
+        fetchServerPackages.mockResolvedValue([
+            {
+                id: 'foo',
+                type: 'app',
+                version: '1.0.0',
+                bundleUrl: 'http://server.test/packages/foo/client.js',
+                sourceRegistry: '',
+                contractVersion: '1',
+            },
+        ]);
+        await loadInstalledPackages();
+        expect(globalThis.fetch).not.toHaveBeenCalled();
+    });
+});

package/dist/registry/types.d.ts

@@ -183,6 +183,25 @@ export interface InstalledPackage {
      * must treat a missing value as `[]`.
      */
     permissions: string[];
+    /**
+     * Shard ids this package contributed at install time. Populated from
+     * `LoadedBundle.shards[].manifest.id`. Used at reinstall to diff against
+     * the new bundle and unregister shards the new version no longer ships.
+     *
+     * Optional for backwards compatibility with records written before this
+     * field existed. Treat a missing value as "unknown" — diffing is skipped
+     * for that record and the field is populated on the next install.
+     */
+    contributedShards?: string[];
+    /**
+     * App ids this package contributed at install time. Populated from
+     * `LoadedBundle.apps[].manifest.id`. Same diff-and-unregister role as
+     * `contributedShards`.
+     *
+     * Optional for backwards compatibility with records written before this
+     * field existed.
+     */
+    contributedApps?: string[];
 }
 /**
  * Result of an install operation.

package/dist/runtime/runVerb.test.js

@@ -175,4 +175,91 @@ describe('runVerbProgrammatic', () => {
         await runVerbProgrammatic('docs-probe-2', 'docs-probe-2:peek', []);
         expect(seenDocs).toBeUndefined();
     });
+    it('surfaces the verb return value as result', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            register(ctx) {
+                ctx.registerVerb({
+                    name: 'returnObj',
+                    summary: 'returns an object',
+                    programmatic: true,
+                    async run() {
+                        return { answer: 'ok', count: 3 };
+                    },
+                });
+            },
+        });
+        await activateShard('tester');
+        const out = await runVerbProgrammatic('tester', 'tester:returnObj', []);
+        expect(out.result).toEqual({ answer: 'ok', count: 3 });
+    });
+    it('surfaces a primitive verb return value as result', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            register(ctx) {
+                ctx.registerVerb({
+                    name: 'returnNumber',
+                    summary: 'returns 42',
+                    programmatic: true,
+                    schema: {
+                        input: { type: 'object' },
+                        output: { type: 'integer' },
+                    },
+                    async run() {
+                        return 42;
+                    },
+                });
+            },
+        });
+        await activateShard('tester');
+        const out = await runVerbProgrammatic('tester', 'tester:returnNumber', []);
+        expect(out.result).toBe(42);
+    });
+    it('surfaces undefined as result for a verb that returns nothing', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            register(ctx) {
+                ctx.registerVerb({
+                    name: 'returnVoid',
+                    summary: 'returns nothing',
+                    programmatic: true,
+                    async run() {
+                        // no return
+                    },
+                });
+            },
+        });
+        await activateShard('tester');
+        const out = await runVerbProgrammatic('tester', 'tester:returnVoid', []);
+        expect(out.result).toBeUndefined();
+    });
+    it('round-trips an sh3-document handle through result', async () => {
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            register(ctx) {
+                ctx.registerVerb({
+                    name: 'returnDoc',
+                    summary: 'returns a document handle',
+                    programmatic: true,
+                    schema: {
+                        input: { type: 'object' },
+                        output: {
+                            type: 'object',
+                            format: 'sh3-document',
+                            properties: {
+                                shardId: { type: 'string' },
+                                path: { type: 'string' },
+                            },
+                        },
+                    },
+                    async run() {
+                        return { shardId: 'notes', path: 'inbox/today.md' };
+                    },
+                });
+            },
+        });
+        await activateShard('tester');
+        const out = await runVerbProgrammatic('tester', 'tester:returnDoc', []);
+        expect(out.result).toEqual({ shardId: 'notes', path: 'inbox/today.md' });
+    });
 });

package/dist/sh3core-shard/Sh3Home.svelte

@@ -18,7 +18,6 @@
   import { makeSelectionApi } from '../actions/selection.svelte';
   import { getAppearance } from '../app-appearance';
   import iconsUrl from '../assets/icons.svg';
-  import { manifest } from '../shell-shard/manifest';
 
   const homeSelection = makeSelectionApi('__sh3core__');
 

package/dist/shards/lifecycle.svelte.d.ts

@@ -112,3 +112,11 @@ export declare function activateShard(id: string): Promise<void>;
  * that explicitly want to verify cleanup paths).
  */
 export declare function deactivateShard(id: string): void;
+/**
+ * Remove a shard from the registry entirely. Deactivates it first if active,
+ * then drops it from `registeredShards` and clears any error record.
+ *
+ * Called by the package installer when a bundle update no longer ships a
+ * shard that the previous version contributed.
+ */
+export declare function unregisterShard(id: string): void;

package/dist/shards/lifecycle.svelte.js

@@ -607,3 +607,20 @@ export function deactivateShard(id) {
     shardEntries.delete(id);
     activeShards.delete(id);
 }
+/**
+ * Remove a shard from the registry entirely. Deactivates it first if active,
+ * then drops it from `registeredShards` and clears any error record.
+ *
+ * Called by the package installer when a bundle update no longer ships a
+ * shard that the previous version contributed.
+ */
+export function unregisterShard(id) {
+    if (!registeredShards.has(id))
+        return;
+    try {
+        deactivateShard(id);
+    }
+    catch ( /* not active */_a) { /* not active */ }
+    registeredShards.delete(id);
+    erroredShards.delete(id);
+}