sh3-core 0.11.8 → 0.13.0

package/dist/primitives/widgets/Textarea.svelte

@@ -0,0 +1,81 @@
+<script lang="ts">
+  let {
+    value = $bindable(''),
+    label,
+    placeholder,
+    helper,
+    error,
+    disabled = false,
+    invalid = false,
+    size = 'md',
+    required = false,
+    rows = 3,
+    resize = 'vertical',
+  }: {
+    value?: string;
+    label?: string;
+    placeholder?: string;
+    helper?: string;
+    error?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+    required?: boolean;
+    rows?: number;
+    resize?: 'none' | 'vertical' | 'both';
+  } = $props();
+
+  const showError = $derived(invalid && !!error);
+  const helperText = $derived(showError ? error : helper);
+</script>
+
+<label class="sh3-textarea" class:sh3-textarea--invalid={invalid} class:sh3-textarea--sm={size === 'sm'}>
+  {#if label}<span class="sh3-textarea__label">{label}{#if required}<span aria-hidden="true"> *</span>{/if}</span>{/if}
+  <textarea
+    class="sh3-textarea__input"
+    style:resize
+    {placeholder}
+    {disabled}
+    {required}
+    {rows}
+    aria-invalid={invalid || undefined}
+    bind:value
+  ></textarea>
+  {#if helperText}<span class="sh3-textarea__helper" class:sh3-textarea__helper--error={showError}>{helperText}</span>{/if}
+</label>
+
+<style>
+  .sh3-textarea {
+    display: inline-flex;
+    flex-direction: column;
+    gap: 4px;
+    font-family: var(--shell-font-ui);
+    font-size: 0.8125rem;
+  }
+  .sh3-textarea__label {
+    color: var(--shell-fg-muted);
+    font-size: 0.75rem;
+  }
+  .sh3-textarea__input {
+    background: var(--shell-input-bg);
+    color: var(--shell-fg);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-widget-radius);
+    padding: var(--shell-pad-sm) var(--shell-field-pad-x);
+    font: inherit;
+    outline: none;
+    transition: border-color var(--shell-motion-fast) var(--shell-ease-standard);
+  }
+  .sh3-textarea__input:focus {
+    border-color: var(--shell-input-border-focus);
+    box-shadow: var(--shell-focus-ring);
+  }
+  .sh3-textarea--invalid .sh3-textarea__input {
+    border-color: var(--shell-error);
+  }
+  .sh3-textarea__helper {
+    color: var(--shell-fg-muted);
+    font-size: 0.75rem;
+  }
+  .sh3-textarea__helper--error { color: var(--shell-error); }
+</style>

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

@@ -0,0 +1,16 @@
+type $$ComponentProps = {
+    value?: string;
+    label?: string;
+    placeholder?: string;
+    helper?: string;
+    error?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+    required?: boolean;
+    rows?: number;
+    resize?: 'none' | 'vertical' | 'both';
+};
+declare const Textarea: import("svelte").Component<$$ComponentProps, {}, "value">;
+type Textarea = ReturnType<typeof Textarea>;
+export default Textarea;

package/dist/primitives/widgets/_select-listbox.svelte

@@ -0,0 +1,228 @@
+<script lang="ts">
+  import { tick } from 'svelte';
+  import {
+    type SelectOption,
+    shouldShowSearch,
+    filterOptions,
+    matchTypeAhead,
+  } from './Select';
+
+  let {
+    options,
+    getValue,
+    multiple,
+    onSelect,
+    onClose,
+    close,
+  }: {
+    options: SelectOption[];
+    /** Live read of the selected value(s). Returning a closure (rather
+     *  than passing value as a snapshot) is what lets the listbox
+     *  re-render checkmarks across multiple selections without unmounting. */
+    getValue: () => string | string[];
+    multiple: boolean;
+    onSelect: (v: string) => void;
+    /** Called by listbox-initiated close paths so the trigger can
+     *  restore its open-flag and focus. Outside-click and Escape
+     *  paths are handled by the popup manager via Select's wrap. */
+    onClose?: () => void;
+    close: () => void;
+  } = $props();
+
+  const value = $derived(getValue());
+
+  function dismiss() {
+    onClose?.();
+    close();
+  }
+
+  const showSearch = $derived(shouldShowSearch(options));
+
+  function initialActiveIdx(): number {
+    if (multiple) return 0;
+    const v = typeof value === 'string' ? value : '';
+    const idx = options.findIndex((o) => o.value === v && !o.disabled);
+    return idx >= 0 ? idx : 0;
+  }
+
+  let query = $state('');
+  let activeIdx = $state(initialActiveIdx());
+  let listEl = $state<HTMLDivElement | undefined>(undefined);
+  let searchEl = $state<HTMLInputElement | undefined>(undefined);
+  let typeAheadBuffer = '';
+  let typeAheadTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const filtered = $derived(filterOptions(options, query));
+
+  $effect(() => {
+    if (activeIdx >= filtered.length) activeIdx = 0;
+    void scrollActiveIntoView();
+  });
+
+  async function scrollActiveIntoView() {
+    await tick();
+    if (!listEl) return;
+    const el = listEl.querySelector<HTMLElement>(`[data-idx="${activeIdx}"]`);
+    el?.scrollIntoView({ block: 'nearest' });
+  }
+
+  function isSelected(o: SelectOption): boolean {
+    if (multiple && Array.isArray(value)) return value.includes(o.value);
+    return value === o.value;
+  }
+
+  function commit(idx: number) {
+    const o = filtered[idx];
+    if (!o || o.disabled) return;
+    onSelect(o.value);
+    if (!multiple) dismiss();
+  }
+
+  function onListKey(e: KeyboardEvent) {
+    if (filtered.length === 0) return;
+    switch (e.key) {
+      case 'ArrowDown':
+        e.preventDefault();
+        activeIdx = (activeIdx + 1) % filtered.length;
+        break;
+      case 'ArrowUp':
+        e.preventDefault();
+        activeIdx = (activeIdx - 1 + filtered.length) % filtered.length;
+        break;
+      case 'Home':
+        e.preventDefault();
+        activeIdx = 0;
+        break;
+      case 'End':
+        e.preventDefault();
+        activeIdx = filtered.length - 1;
+        break;
+      case 'Enter':
+        e.preventDefault();
+        commit(activeIdx);
+        break;
+      case ' ':
+      case 'Space':
+        e.preventDefault();
+        commit(activeIdx);
+        break;
+      case 'Escape':
+        e.preventDefault();
+        dismiss();
+        break;
+      default:
+        if (showSearch && document.activeElement === searchEl) return;
+        if (e.key.length !== 1 || e.metaKey || e.ctrlKey || e.altKey) return;
+        typeAheadBuffer += e.key;
+        if (typeAheadTimer) clearTimeout(typeAheadTimer);
+        typeAheadTimer = setTimeout(() => { typeAheadBuffer = ''; }, 500);
+        const idx = matchTypeAhead(filtered, typeAheadBuffer, activeIdx);
+        if (idx >= 0) activeIdx = idx;
+    }
+  }
+</script>
+
+<div
+  class="sh3-listbox"
+  role="listbox"
+  aria-multiselectable={multiple}
+  tabindex="-1"
+  onkeydown={onListKey}
+>
+  {#if showSearch}
+    <input
+      bind:this={searchEl}
+      class="sh3-listbox__search"
+      type="search"
+      placeholder="Filter…"
+      bind:value={query}
+    />
+  {/if}
+  <div class="sh3-listbox__list" bind:this={listEl}>
+    {#each filtered as opt, i}
+      <!-- svelte-ignore a11y_click_events_have_key_events -->
+      <div
+        role="option"
+        tabindex="-1"
+        aria-selected={isSelected(opt)}
+        aria-disabled={opt.disabled}
+        data-idx={i}
+        class:sh3-listbox__opt--active={i === activeIdx}
+        class:sh3-listbox__opt--selected={isSelected(opt)}
+        onclick={() => commit(i)}
+        onmouseenter={() => activeIdx = i}
+      >
+        {#if multiple}
+          <span class="sh3-listbox__check" class:sh3-listbox__check--on={isSelected(opt)} aria-hidden="true"></span>
+        {/if}
+        <span class="sh3-listbox__label">{opt.label}</span>
+      </div>
+    {/each}
+    {#if filtered.length === 0}
+      <div class="sh3-listbox__empty">No matches</div>
+    {/if}
+  </div>
+</div>
+
+<style>
+  .sh3-listbox {
+    background: var(--shell-bg-elevated);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-widget-radius);
+    box-shadow: var(--shell-shadow-sm);
+    min-width: 180px;
+    max-width: 320px;
+    color: var(--shell-fg);
+    font-size: 0.8125rem;
+    overflow: hidden;
+  }
+  .sh3-listbox__search {
+    width: 100%;
+    height: 26px;
+    padding: 0 8px;
+    background: var(--shell-input-bg);
+    border: none;
+    border-bottom: 1px solid var(--shell-border);
+    color: var(--shell-fg);
+    font: inherit;
+    outline: none;
+  }
+  .sh3-listbox__list {
+    max-height: 280px;
+    overflow-y: auto;
+    padding: 4px 0;
+  }
+  .sh3-listbox__list > div {
+    display: flex; align-items: center; gap: 6px;
+    padding: 4px 10px;
+    cursor: pointer;
+  }
+  .sh3-listbox__opt--active { background: var(--shell-bg); }
+  .sh3-listbox__opt--selected { color: var(--shell-accent); }
+  .sh3-listbox__opt--active.sh3-listbox__opt--selected { background: var(--shell-accent); color: var(--shell-fg-on-accent); }
+  .sh3-listbox__list > div[aria-disabled="true"] {
+    color: var(--shell-fg-subtle);
+    cursor: not-allowed;
+  }
+  .sh3-listbox__check {
+    flex-shrink: 0;
+    width: 12px;
+    height: 12px;
+  }
+  .sh3-listbox__check--on::before {
+    content: "";
+    display: block;
+    width: 100%;
+    height: 100%;
+    background: var(--shell-accent);
+    clip-path: polygon(14% 44%, 0 60%, 40% 100%, 100% 20%, 85% 8%, 38% 70%);
+  }
+  .sh3-listbox__opt--active.sh3-listbox__opt--selected .sh3-listbox__check--on::before {
+    background: var(--shell-fg-on-accent);
+  }
+  .sh3-listbox__empty {
+    padding: 6px 10px;
+    color: var(--shell-fg-muted);
+    font-style: italic;
+  }
+</style>

package/dist/primitives/widgets/_select-listbox.svelte.d.ts

@@ -0,0 +1,18 @@
+import { type SelectOption } from './Select';
+type $$ComponentProps = {
+    options: SelectOption[];
+    /** Live read of the selected value(s). Returning a closure (rather
+     *  than passing value as a snapshot) is what lets the listbox
+     *  re-render checkmarks across multiple selections without unmounting. */
+    getValue: () => string | string[];
+    multiple: boolean;
+    onSelect: (v: string) => void;
+    /** Called by listbox-initiated close paths so the trigger can
+     *  restore its open-flag and focus. Outside-click and Escape
+     *  paths are handled by the popup manager via Select's wrap. */
+    onClose?: () => void;
+    close: () => void;
+};
+declare const SelectListbox: import("svelte").Component<$$ComponentProps, {}, "">;
+type SelectListbox = ReturnType<typeof SelectListbox>;
+export default SelectListbox;

package/dist/shards/activate-error-isolation.test.d.ts

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

package/dist/shards/activate-error-isolation.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { __setDocumentBackend, __setTenantId } from '../documents/config';
+import { registerShard, activateShard, registeredShards, activeShards, __resetShardRegistryForTest, erroredShards, } from './activate.svelte';
+describe('erroredShards map', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-a');
+    });
+    it('is empty after reset', () => {
+        expect(erroredShards.size).toBe(0);
+    });
+    it('supports the Map read API used by callers', () => {
+        expect(typeof erroredShards.has).toBe('function');
+        expect(typeof erroredShards.get).toBe('function');
+        expect(erroredShards.has('anything')).toBe(false);
+    });
+});
+describe('activateShard — unwind on activation failure', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-a');
+    });
+    it('unwinds partial state and records the error when activate throws', async () => {
+        const shard = {
+            manifest: {
+                id: 'broken',
+                label: 'Broken',
+                version: '0.0.0',
+                views: [],
+            },
+            activate(ctx) {
+                ctx.registerView('broken:view', { mount: () => ({ unmount() { } }) });
+                throw new Error('dependency missing');
+            },
+        };
+        registerShard(shard);
+        await expect(activateShard('broken')).rejects.toThrow('dependency missing');
+        expect(activeShards.has('broken')).toBe(false);
+        expect(registeredShards.has('broken')).toBe(true);
+        const entry = erroredShards.get('broken');
+        expect(entry).toBeDefined();
+        expect(entry === null || entry === void 0 ? void 0 : entry.id).toBe('broken');
+        expect(entry === null || entry === void 0 ? void 0 : entry.phase).toBe('launch');
+        expect(entry === null || entry === void 0 ? void 0 : entry.error).toBeInstanceOf(Error);
+        expect(typeof (entry === null || entry === void 0 ? void 0 : entry.timestamp)).toBe('number');
+        const { getView } = await import('./registry');
+        expect(getView('broken:view')).toBeUndefined();
+    });
+    it('records phase "autostart" when called with that option', async () => {
+        var _a;
+        const shard = {
+            manifest: { id: 'broken-auto', label: 'B', version: '0.0.0', views: [] },
+            activate() {
+                throw new Error('no');
+            },
+        };
+        registerShard(shard);
+        await expect(activateShard('broken-auto', { phase: 'autostart' })).rejects.toThrow('no');
+        expect((_a = erroredShards.get('broken-auto')) === null || _a === void 0 ? void 0 : _a.phase).toBe('autostart');
+    });
+    it('clears the error entry when the shard is re-registered', async () => {
+        const broken = {
+            manifest: { id: 'reborn', label: 'R', version: '0.0.0', views: [] },
+            activate() {
+                throw new Error('first try');
+            },
+        };
+        registerShard(broken);
+        await expect(activateShard('reborn')).rejects.toThrow('first try');
+        expect(erroredShards.has('reborn')).toBe(true);
+        const fixed = {
+            manifest: { id: 'reborn', label: 'R', version: '0.0.1', views: [] },
+            activate() { },
+        };
+        registerShard(fixed);
+        expect(erroredShards.has('reborn')).toBe(false);
+    });
+    it('clears the error entry when activation eventually succeeds', async () => {
+        let shouldFail = true;
+        const shard = {
+            manifest: { id: 'flaky', label: 'F', version: '0.0.0', views: [] },
+            activate() {
+                if (shouldFail)
+                    throw new Error('first try');
+            },
+        };
+        registerShard(shard);
+        await expect(activateShard('flaky')).rejects.toThrow('first try');
+        expect(erroredShards.has('flaky')).toBe(true);
+        shouldFail = false;
+        await activateShard('flaky');
+        expect(erroredShards.has('flaky')).toBe(false);
+        expect(activeShards.has('flaky')).toBe(true);
+    });
+});

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

@@ -9,6 +9,19 @@ import type { Shard, ShardContext } from './types';
  */
 export declare const registeredShards: Map<string, Shard>;
 export declare const activeShards: Map<string, Shard>;
+/**
+ * Reactive map of shard ids that failed to activate. Populated by
+ * `activateShard`'s catch block; cleared when the shard is successfully
+ * re-registered or activated. Read-only for shards; intended for diagnostic
+ * and admin tooling that wants to surface broken shards to the user.
+ */
+export interface ShardErrorEntry {
+    id: string;
+    error: unknown;
+    phase: 'autostart' | 'launch';
+    timestamp: number;
+}
+export declare const erroredShards: Map<string, ShardErrorEntry>;
 /**
  * Register (or re-register) a shard with the framework so it can later be
  * activated. Records the shard in `registeredShards` but does not run
@@ -20,16 +33,31 @@ export declare const activeShards: Map<string, Shard>;
  * activated on next launch.
  */
 export declare function registerShard(shard: Shard): void;
+export interface ActivateShardOpts {
+    /**
+     * Where this activation was initiated from. Determines the `phase` field
+     * recorded in `erroredShards` if activation fails. Defaults to 'launch'
+     * (the common case — required by an app being launched).
+     */
+    phase?: 'autostart' | 'launch';
+}
 /**
  * Activate a registered shard. Builds a `ShardContext`, calls `shard.activate`,
  * verifies that every view declared in the manifest received a factory, then
  * calls `shard.autostart` if defined. Idempotent — calling on an already-active
  * shard is a no-op.
  *
+ * If `shard.activate` throws, partial state (registered views, verbs,
+ * contributions, document handles, actions, env subscription) is unwound
+ * and the failure is recorded in `erroredShards` before the error is
+ * re-thrown. Callers in `host.ts` (autostart loop) and `launchApp`
+ * (required-shard loop) decide how to react.
+ *
  * @param id - The `ShardManifest.id` of the shard to activate. Must be registered.
- * @throws If the shard is not registered, or if a manifest view has no factory after activation.
+ * @param opts - Optional. `phase` is recorded in `erroredShards` on failure (default 'launch').
+ * @throws If the shard is not registered, if `shard.activate` throws, or if a manifest view has no factory after activation.
  */
-export declare function activateShard(id: string): Promise<void>;
+export declare function activateShard(id: string, opts?: ActivateShardOpts): Promise<void>;
 /**
  * Deactivate an active shard. Calls `shard.deactivate`, flushes and disposes
  * all document handles, unregisters all view factories, and removes the shard

package/dist/shards/activate.svelte.js

@@ -47,6 +47,7 @@ export const registeredShards = $state(new Map());
  */
 const active = new Map();
 export const activeShards = $state(new Map());
+export const erroredShards = $state(new Map());
 /**
  * Register (or re-register) a shard with the framework so it can later be
  * activated. Records the shard in `registeredShards` but does not run
@@ -63,6 +64,9 @@ export function registerShard(shard) {
         deactivateShard(id);
     }
     registeredShards.set(id, shard);
+    // Re-registering wipes any prior error: the new shard module gets a
+    // clean slate, and a hot-reload of a fixed shard removes the stale entry.
+    erroredShards.delete(id);
 }
 /**
  * Activate a registered shard. Builds a `ShardContext`, calls `shard.activate`,
@@ -70,11 +74,18 @@ export function registerShard(shard) {
  * calls `shard.autostart` if defined. Idempotent — calling on an already-active
  * shard is a no-op.
  *
+ * If `shard.activate` throws, partial state (registered views, verbs,
+ * contributions, document handles, actions, env subscription) is unwound
+ * and the failure is recorded in `erroredShards` before the error is
+ * re-thrown. Callers in `host.ts` (autostart loop) and `launchApp`
+ * (required-shard loop) decide how to react.
+ *
  * @param id - The `ShardManifest.id` of the shard to activate. Must be registered.
- * @throws If the shard is not registered, or if a manifest view has no factory after activation.
+ * @param opts - Optional. `phase` is recorded in `erroredShards` on failure (default 'launch').
+ * @throws If the shard is not registered, if `shard.activate` throws, or if a manifest view has no factory after activation.
  */
-export async function activateShard(id) {
-    var _a, _b, _c, _d, _e;
+export async function activateShard(id, opts) {
+    var _a, _b, _c, _d, _e, _f;
     const shard = registeredShards.get(id);
     if (!shard) {
         throw new Error(`Cannot activate shard "${id}": not registered`);
@@ -201,24 +212,57 @@ export async function activateShard(id) {
     }
     active.set(id, entry);
     activeShards.set(id, shard);
-    await shard.activate(ctx);
-    for (const view of shard.manifest.views) {
-        if (!entry.viewIds.has(view.id)) {
-            throw new Error(`Shard "${id}" declared view "${view.id}" in its manifest but registered no factory for it.`);
+    try {
+        await shard.activate(ctx);
+        for (const view of shard.manifest.views) {
+            if (!entry.viewIds.has(view.id)) {
+                throw new Error(`Shard "${id}" declared view "${view.id}" in its manifest but registered no factory for it.`);
+            }
         }
-    }
-    // Hydrate env state if the shard declared it via ctx.env().
-    if (envState.proxy && envState.defaults) {
-        try {
-            const stored = await fetchEnvState(id);
-            const merged = Object.assign({}, envState.defaults, stored);
-            Object.assign(envState.proxy, merged);
+        // Hydrate env state if the shard declared it via ctx.env().
+        if (envState.proxy && envState.defaults) {
+            try {
+                const stored = await fetchEnvState(id);
+                const merged = Object.assign({}, envState.defaults, stored);
+                Object.assign(envState.proxy, merged);
+            }
+            catch (err) {
+                console.warn(`[sh3] Failed to hydrate env state for shard "${id}":`, err instanceof Error ? err.message : err);
+            }
         }
-        catch (err) {
-            console.warn(`[sh3] Failed to hydrate env state for shard "${id}":`, err instanceof Error ? err.message : err);
+    }
+    catch (err) {
+        // Unwind partial state. Mirror deactivateShard's body, minus the
+        // shard.deactivate?.() call — the shard never finished activating.
+        // Each cleanup fn runs inside its own swallow so a teardown failure
+        // cannot mask the original activation error.
+        for (const fn of entry.cleanupFns) {
+            try {
+                void fn();
+            }
+            catch (_g) {
+                // intentionally swallowed: original error is what matters.
+            }
         }
+        for (const name of entry.verbNames)
+            fwUnregisterVerb(name);
+        for (const viewId of entry.viewIds)
+            unregisterView(viewId);
+        clearSelectionForShard(id);
+        active.delete(id);
+        activeShards.delete(id);
+        erroredShards.set(id, {
+            id,
+            error: err,
+            phase: (_e = opts === null || opts === void 0 ? void 0 : opts.phase) !== null && _e !== void 0 ? _e : 'launch',
+            timestamp: Date.now(),
+        });
+        console.error(`[sh3] Shard "${id}" failed to activate:`, err);
+        throw err;
     }
-    void ((_e = shard.autostart) === null || _e === void 0 ? void 0 : _e.call(shard, ctx));
+    // Activation succeeded — clear any prior error record for this shard.
+    erroredShards.delete(id);
+    void ((_f = shard.autostart) === null || _f === void 0 ? void 0 : _f.call(shard, ctx));
 }
 /**
  * Deactivate an active shard. Calls `shard.deactivate`, flushes and disposes
@@ -288,4 +332,5 @@ export function __resetShardRegistryForTest() {
     active.clear();
     activeShards.clear();
     registeredShards.clear();
+    erroredShards.clear();
 }

package/dist/shell-shard/Terminal.svelte

@@ -78,10 +78,6 @@
   let focusLocked = $state(false);
   let targetShard = $state<string | null>(null);
 
-  function toggleFocusLock(): void {
-    focusLocked = !focusLocked;
-  }
-
   // Toolbar slot registry
   const toolbarRegistry = new ToolbarSlotRegistry();
   toolbarRegistry.register({ id: 'mode', order: 10, visible: () => true, component: ModeSlot });
@@ -101,6 +97,7 @@
         const found = getActiveViewId(child);
         if (found !== null) return found;
       }
+      return null;
     }
     // slot node
     return node.viewId ?? null;

package/dist/shell-shard/verbs/index.js

@@ -13,6 +13,7 @@ import { pwdVerb, cdVerb, whoamiVerb } from './session';
 import { envVerb } from './env';
 import { lsVerb } from './ls';
 import { catVerb } from './cat';
+import { resetVerb } from './reset';
 export function registerV1Verbs(ctx) {
     ctx.registerVerb(makeHelpVerb());
     ctx.registerVerb(clearVerb);
@@ -33,4 +34,5 @@ export function registerV1Verbs(ctx) {
     ctx.registerVerb(whoamiVerb);
     ctx.registerVerb(lsVerb);
     ctx.registerVerb(catVerb);
+    ctx.registerVerb(resetVerb);
 }

package/dist/shell-shard/verbs/reset.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const resetVerb: Verb;

package/dist/shell-shard/verbs/reset.js

@@ -0,0 +1,26 @@
+import { wipeUserData } from '../../platform/index';
+export const resetVerb = {
+    name: 'reset',
+    summary: 'Wipe SH3 state and reload (preserves documents). Requires --confirm.',
+    async run(ctx, args) {
+        if (!args.includes('--confirm')) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: 'reset: erases the package registry, all zone state (including Tauri stores), ' +
+                    'and theme overrides, then reloads. Documents are preserved. ' +
+                    'Re-run as `reset --confirm` to proceed.',
+                level: 'warn',
+                ts: Date.now(),
+            });
+            return;
+        }
+        ctx.scrollback.push({
+            kind: 'status',
+            text: 'reset: wiping data…',
+            level: 'info',
+            ts: Date.now(),
+        });
+        await wipeUserData();
+        location.reload();
+    },
+};