sh3-core 0.17.0 → 0.19.0

package/dist/overlays/focusTrap.d.ts

@@ -1 +1,11 @@
-export declare function createFocusTrap(container: HTMLElement): () => void;
+export interface FocusTrapOptions {
+    /**
+     * When false, skip moving focus into the container on install. Tab
+     * cycling and previous-focus restoration still work — this only
+     * suppresses the initial auto-focus. Used by the command palette on
+     * touch-only devices to keep the on-screen keyboard from popping
+     * up unprompted.
+     */
+    initialFocus?: boolean;
+}
+export declare function createFocusTrap(container: HTMLElement, options?: FocusTrapOptions): () => void;

package/dist/overlays/focusTrap.js

@@ -20,7 +20,7 @@ const FOCUSABLE_SELECTOR = [
     'textarea:not([disabled])',
     '[tabindex]:not([tabindex="-1"])',
 ].join(',');
-export function createFocusTrap(container) {
+export function createFocusTrap(container, options = {}) {
     const previouslyFocused = document.activeElement;
     function getFocusables() {
         return Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR));
@@ -47,14 +47,16 @@ export function createFocusTrap(container) {
         }
     }
     container.addEventListener('keydown', onKeydown);
-    // Defer initial focus to the next microtask so the container contents
-    // (which may still be rendering if createFocusTrap was called mid-mount)
-    // have a chance to appear in the DOM.
-    queueMicrotask(() => {
-        var _a;
-        const focusables = getFocusables();
-        ((_a = focusables[0]) !== null && _a !== void 0 ? _a : container).focus();
-    });
+    if (options.initialFocus !== false) {
+        // Defer initial focus to the next microtask so the container contents
+        // (which may still be rendering if createFocusTrap was called mid-mount)
+        // have a chance to appear in the DOM.
+        queueMicrotask(() => {
+            var _a;
+            const focusables = getFocusables();
+            ((_a = focusables[0]) !== null && _a !== void 0 ? _a : container).focus();
+        });
+    }
     return () => {
         container.removeEventListener('keydown', onKeydown);
         if (previouslyFocused && document.contains(previouslyFocused)) {

package/dist/overlays/modal.js

@@ -132,6 +132,7 @@ function openModal(Content, props, options) {
             close: handle.close,
             boxStyle: options === null || options === void 0 ? void 0 : options.boxStyle,
             onBackdropClick: (options === null || options === void 0 ? void 0 : options.dismissOnBackdrop) ? handle.close : undefined,
+            initialFocus: options === null || options === void 0 ? void 0 : options.initialFocus,
         },
     });
     entry.host = host;

package/dist/overlays/popup.js

@@ -26,6 +26,7 @@
  *   - close() is idempotent.
  */
 import { mount, unmount } from 'svelte';
+import { getOwner } from '../gestures';
 import PopupFrame from './PopupFrame.svelte';
 import { getLayerRoot } from './roots';
 import { registerDismissable } from '../navigation/back-stack';
@@ -44,6 +45,9 @@ let current = null;
 function onDocumentPointerDown(e) {
     if (!current)
         return;
+    // Skip dismiss if a gesture owns this pointer.
+    if (getOwner(e.pointerId))
+        return;
     const target = e.target;
     if (target && current.host.contains(target))
         return;

package/dist/overlays/types.d.ts

@@ -1,4 +1,4 @@
-export type OverlayLayer = 'floating' | 'drag-preview' | 'popup' | 'modal' | 'toast' | 'command';
+export type OverlayLayer = 'drawers' | 'floating' | 'drag-preview' | 'popup' | 'modal' | 'toast' | 'command';
 /** A handle returned by every overlay opener. Calling close() is idempotent. */
 export interface OverlayHandle {
     close(): void;
@@ -44,4 +44,13 @@ export interface ModalOptions {
      * expected dismissal gesture.
      */
     dismissOnBackdrop?: boolean;
+    /**
+     * When false, suppress the focus trap's initial auto-focus on the
+     * modal's first focusable descendant. Tab cycling within the trap
+     * still works, and previous-focus is still restored on close.
+     * Default true. Opt-out is for cases where focusing an input pops
+     * an on-screen keyboard the user didn't ask for (e.g. command
+     * palette on touch-only devices).
+     */
+    initialFocus?: boolean;
 }

package/dist/primitives/Button.svelte

@@ -21,6 +21,7 @@
     sprite,
     disabled = false,
     loading,
+    pressed,
     type = 'button',
     title,
     ariaLabel,
@@ -35,6 +36,12 @@
     disabled?: boolean;
     /** Controlled pending state. When true, spinner + disabled + aria-busy. */
     loading?: boolean;
+    /**
+     * Toggle state for toolbar/action buttons. When provided, sets
+     * aria-pressed and applies a pressed visual treatment. Orthogonal
+     * to `variant` — works with any variant.
+     */
+    pressed?: boolean;
     type?: 'button' | 'submit' | 'reset';
     title?: string;
     ariaLabel?: string;
@@ -77,8 +84,10 @@
   {type}
   class="sh3-btn sh3-btn--{variant}"
   class:sh3-btn--icon-only={iconOnly}
+  class:sh3-btn--pressed={pressed}
   disabled={disabled || pending}
   aria-busy={pending || undefined}
+  aria-pressed={pressed ?? undefined}
   {title}
   aria-label={ariaLabel ?? (iconOnly ? title : undefined)}
   onclick={handleClick}
@@ -134,6 +143,15 @@
     cursor: not-allowed;
   }
 
+  /* pressed=true: inset shadow + slight dimming to signal toggle-on state */
+  .sh3-btn--pressed {
+    box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.35);
+    filter: brightness(0.88);
+  }
+  .sh3-btn--pressed:hover:not(:disabled) {
+    filter: brightness(0.96);
+  }
+
   .sh3-btn--alert {
     background: var(--sh3-error);
     color: var(--sh3-fg-on-error);

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

@@ -9,6 +9,12 @@ type $$ComponentProps = {
     disabled?: boolean;
     /** Controlled pending state. When true, spinner + disabled + aria-busy. */
     loading?: boolean;
+    /**
+     * Toggle state for toolbar/action buttons. When provided, sets
+     * aria-pressed and applies a pressed visual treatment. Orthogonal
+     * to `variant` — works with any variant.
+     */
+    pressed?: boolean;
     type?: 'button' | 'submit' | 'reset';
     title?: string;
     ariaLabel?: string;

package/dist/primitives/ResizableSplitter.svelte

@@ -19,6 +19,8 @@
 
   import type { Snippet } from 'svelte';
   import type { SizeMode, SplitDirection } from '../layout/types';
+  import { claim, revoke } from '../gestures/pointerClaim';
+  import { ancestorCount } from '../gestures';
 
   const MIN_PX = 40;
   const COLLAPSED_PX = 28;
@@ -33,6 +35,7 @@
     pane,
     onResize,
     onCollapseToggle,
+    compact = false,
   }: {
     direction: SplitDirection;
     /**
@@ -69,6 +72,14 @@
     onResize?: (index: number, value: number) => void;
     /** Called when a collapsed pane's header is clicked to toggle. */
     onCollapseToggle?: (index: number, collapsed: boolean) => void;
+    /**
+     * Compact-mode rendering: drops the per-pane collapse arrows (the
+     * 16px side rail eats too much room on a phone) and freezes the
+     * resize handles into thin visual separators with no drag gesture.
+     * Existing collapsed panes stay visually collapsed but lose the
+     * expand affordance until the viewport flips back.
+     */
+    compact?: boolean;
   } = $props();
 
   let container: HTMLDivElement;
@@ -103,12 +114,19 @@
   };
 
   let drag: DragState | null = $state(null);
+  let activeDragPointerId: number | null = null;
 
   function beginDrag(e: PointerEvent, handleIndex: number) {
     // Disable resize handles adjacent to collapsed or fixed panes.
+    if (compact) return;
     if (isCollapsed(handleIndex) || isCollapsed(handleIndex + 1)) return;
     if (isHandleFrozen(handleIndex)) return;
 
+    const depth = container ? ancestorCount(container) : 0;
+    const claimGranted = claim(e.pointerId, { ownerId: 'sh3:splitter', axis: 'xy', priority: 'normal', depth });
+    if (!claimGranted) return;
+    activeDragPointerId = e.pointerId;
+
     e.preventDefault();
     (e.target as HTMLElement).setPointerCapture(e.pointerId);
 
@@ -188,6 +206,10 @@
   function endDrag(e: PointerEvent) {
     if (!drag) return;
     (e.target as HTMLElement).releasePointerCapture(e.pointerId);
+    if (activeDragPointerId !== null) {
+      revoke(activeDragPointerId, 'sh3:splitter');
+      activeDragPointerId = null;
+    }
     drag = null;
   }
 </script>
@@ -196,6 +218,7 @@
   class="splitter"
   class:horizontal={direction === 'horizontal'}
   class:vertical={direction === 'vertical'}
+  class:compact
   bind:this={container}
 >
   {#each Array(count) as _, i (i)}
@@ -205,18 +228,33 @@
       style="flex: {flexFor(i)};"
     >
       {#if isCollapsed(i)}
-        <button
-          type="button"
-          class="collapse-header"
-          class:horizontal={direction === 'horizontal'}
-          class:vertical={direction === 'vertical'}
-          onclick={() => onCollapseToggle?.(i, false)}
-          aria-label="Expand pane"
-        >
-          <span class="collapse-icon">{direction === 'horizontal' ? '▸' : '▾'}</span>
-        </button>
+        {#if compact}
+          <!--
+            Compact mode strands collapsed panes — the toggle isn't shown
+            so they can't be expanded until the viewport flips back to
+            desktop. Render an inert placeholder rather than a disabled
+            button so taps don't register at all.
+          -->
+          <div
+            class="collapse-header inert"
+            class:horizontal={direction === 'horizontal'}
+            class:vertical={direction === 'vertical'}
+            aria-hidden="true"
+          ></div>
+        {:else}
+          <button
+            type="button"
+            class="collapse-header"
+            class:horizontal={direction === 'horizontal'}
+            class:vertical={direction === 'vertical'}
+            onclick={() => onCollapseToggle?.(i, false)}
+            aria-label="Expand pane"
+          >
+            <span class="collapse-icon">{direction === 'horizontal' ? '▸' : '▾'}</span>
+          </button>
+        {/if}
       {:else}
-        {#if onCollapseToggle && canCollapse(i)}
+        {#if !compact && onCollapseToggle && canCollapse(i)}
           <button
             type="button"
             class="collapse-header expanded"
@@ -367,4 +405,26 @@
   }
   .horizontal > .splitter-handle.frozen { width: 1px; }
   .vertical   > .splitter-handle.frozen { height: 1px; }
+
+  /*
+   * Compact mode: handles are pure visual separators — 1px, no cursor
+   * change, no pointer events (so taps fall through to the panes
+   * beneath). Mirrors how the .frozen variant degrades a fixed-pane
+   * boundary, but applies to every handle in the splitter.
+   */
+  .splitter.compact > .splitter-handle {
+    pointer-events: none;
+    cursor: default;
+    opacity: 0.6;
+  }
+  .splitter.compact.horizontal > .splitter-handle { width: 1px; }
+  .splitter.compact.vertical   > .splitter-handle { height: 1px; }
+  .splitter.compact > .splitter-handle:hover {
+    background: var(--sh3-border);
+  }
+  .collapse-header.inert {
+    pointer-events: none;
+    background: var(--sh3-bg-elevated);
+    flex: 0 0 auto;
+  }
 </style>

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

@@ -36,6 +36,14 @@ type $$ComponentProps = {
     onResize?: (index: number, value: number) => void;
     /** Called when a collapsed pane's header is clicked to toggle. */
     onCollapseToggle?: (index: number, collapsed: boolean) => void;
+    /**
+     * Compact-mode rendering: drops the per-pane collapse arrows (the
+     * 16px side rail eats too much room on a phone) and freezes the
+     * resize handles into thin visual separators with no drag gesture.
+     * Existing collapsed panes stay visually collapsed but lose the
+     * expand affordance until the viewport flips back.
+     */
+    compact?: boolean;
 };
 declare const ResizableSplitter: import("svelte").Component<$$ComponentProps, {}, "">;
 type ResizableSplitter = ReturnType<typeof ResizableSplitter>;

package/dist/primitives/ResizableSplitter.svelte.test.d.ts

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

package/dist/primitives/ResizableSplitter.svelte.test.js

@@ -0,0 +1,74 @@
+/*
+ * Compact-mode behavior pin for ResizableSplitter — when `compact=true`,
+ * the per-pane collapse arrow is not rendered, the root carries the
+ * `.compact` class (which CSS uses to thin handles + freeze pointer
+ * events), and pointer-down on a handle does not start a drag.
+ *
+ * Resize / drag / collapse interactions in desktop mode are covered by
+ * LayoutRenderer.browser.test.ts; this file pins the new gate only.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { claim, __resetForTest as resetClaims } from '../gestures/pointerClaim';
+import { mount, unmount, flushSync } from 'svelte';
+import ResizableSplitter from './ResizableSplitter.svelte';
+const SplitterAny = ResizableSplitter;
+let mounted = null;
+let host = null;
+function renderHost(props) {
+    host = document.createElement('div');
+    host.style.cssText = 'position: relative; width: 600px; height: 400px;';
+    document.body.appendChild(host);
+    mounted = mount(SplitterAny, { target: host, props });
+    flushSync();
+    return host;
+}
+afterEach(() => {
+    if (mounted) {
+        unmount(mounted);
+        mounted = null;
+    }
+    if (host) {
+        host.remove();
+        host = null;
+    }
+    resetClaims();
+});
+describe('ResizableSplitter compact-mode (dom)', () => {
+    const baseProps = (extra = {}) => (Object.assign({ direction: 'horizontal', sizes: [0.5, 0.5], count: 2, pane: () => null, onResize: () => { }, onCollapseToggle: () => { } }, extra));
+    it('desktop mode: collapse-toggle buttons render for each pane', () => {
+        const el = renderHost(baseProps({ compact: false }));
+        expect(el.querySelectorAll('[data-testid^="collapse-toggle-"]').length).toBe(2);
+        expect(el.querySelector('.splitter').classList.contains('compact')).toBe(false);
+    });
+    it('compact mode: no collapse-toggle buttons render', () => {
+        const el = renderHost(baseProps({ compact: true }));
+        expect(el.querySelectorAll('[data-testid^="collapse-toggle-"]').length).toBe(0);
+    });
+    it('compact mode: root carries .compact class', () => {
+        const el = renderHost(baseProps({ compact: true }));
+        expect(el.querySelector('.splitter').classList.contains('compact')).toBe(true);
+    });
+    it('compact mode: pointerdown on a handle does not begin a drag (no .dragging class)', () => {
+        const el = renderHost(baseProps({ compact: true }));
+        const handle = el.querySelector('.splitter-handle');
+        expect(handle).not.toBeNull();
+        // Simulate pointerdown — beginDrag should bail before adding .dragging.
+        const evt = new PointerEvent('pointerdown', { bubbles: true, pointerId: 1 });
+        handle.dispatchEvent(evt);
+        flushSync();
+        expect(handle.classList.contains('dragging')).toBe(false);
+    });
+});
+describe('ResizableSplitter PointerClaim integration', () => {
+    const baseProps = (extra = {}) => (Object.assign({ direction: 'horizontal', sizes: [0.5, 0.5], count: 2, pane: () => null, onResize: () => { }, onCollapseToggle: () => { } }, extra));
+    it('does not begin drag when pointer is already claimed', () => {
+        const el = renderHost(baseProps({ compact: false }));
+        const handle = el.querySelector('.splitter-handle');
+        expect(handle).not.toBeNull();
+        claim(1, { ownerId: 'app:pan', axis: 'xy', priority: 'normal', depth: 99 });
+        const evt = new PointerEvent('pointerdown', { bubbles: true, pointerId: 1, isPrimary: true });
+        handle.dispatchEvent(evt);
+        flushSync();
+        expect(handle.classList.contains('dragging')).toBe(false);
+    });
+});

package/dist/server-shard/types.d.ts

@@ -33,7 +33,8 @@ export interface TenantDocumentAPI {
         shardId: string;
         path: string;
         content: string | Uint8Array;
-        incomingVersion: number;
+        /** The exact version the store will write. Not auto-incremented. */
+        assignedVersion: number;
         expectedLocalVersion: number;
         origin: string;
         deleted?: boolean;

package/dist/sh3Api/headless.js

@@ -300,7 +300,15 @@ export function makeSh3Api(opts) {
         },
         listActions(actionOpts) {
             const all = listActionsFromEntries(listActionEntriesFromRegistry(), getLiveDispatcherState());
-            return (actionOpts === null || actionOpts === void 0 ? void 0 : actionOpts.activeOnly) ? all.filter((a) => a.active) : all;
+            let out = all;
+            if ((actionOpts === null || actionOpts === void 0 ? void 0 : actionOpts.submenuOf) !== undefined) {
+                const parent = actionOpts.submenuOf;
+                out = out.filter((a) => a.submenuOf === parent);
+            }
+            if (actionOpts === null || actionOpts === void 0 ? void 0 : actionOpts.activeOnly) {
+                out = out.filter((a) => a.active);
+            }
+            return out;
         },
         runAction(id, runOpts) {
             return dispatchActionProgrammatic(id, runOpts);

package/dist/sh3Api/headless.svelte.test.js

@@ -1,5 +1,8 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeEach } from 'vitest';
 import { makeSh3Api } from './headless';
+import { registerAction, __resetActionsRegistryForTest, } from '../actions/registry';
+import { __resetContributionsForTest } from '../contributions/registry';
+import { __resetDispatcherStateForTest } from '../actions/state.svelte';
 function makeMockZoneManager() {
     const data = {
         ephemeral: {},
@@ -57,3 +60,44 @@ describe('sh3Api readZone', () => {
         expect(api.readZone('not-a-shard', 'workspace')).toBe(null);
     });
 });
+describe('sh3Api listActions submenu filter', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        __resetActionsRegistryForTest();
+        __resetDispatcherStateForTest();
+    });
+    it('returns only children of the named parent when { submenuOf } is set', () => {
+        registerAction({ id: 'theme.set', label: 'Theme', scope: 'home', submenu: true }, 'shard.x');
+        registerAction({
+            id: 'theme.set:dark', label: 'Dark', scope: 'home',
+            submenuOf: 'theme.set', run: () => { },
+        }, 'shard.x');
+        registerAction({
+            id: 'theme.set:light', label: 'Light', scope: 'home',
+            submenuOf: 'theme.set', run: () => { },
+        }, 'shard.x');
+        registerAction({ id: 'unrelated', label: 'U', scope: 'home', run: () => { } }, 'shard.x');
+        const api = makeSh3Api({ callerKind: 'verb' });
+        const ids = api.listActions({ submenuOf: 'theme.set' }).map((d) => d.id);
+        expect(ids.sort()).toEqual(['theme.set:dark', 'theme.set:light']);
+    });
+    it('returns [] when no children match the parent id', () => {
+        registerAction({ id: 'home.go', label: 'Go', scope: 'home', run: () => { } }, 'shard.x');
+        const api = makeSh3Api({ callerKind: 'verb' });
+        expect(api.listActions({ submenuOf: 'nope' })).toEqual([]);
+    });
+    it('combines with { activeOnly } — both predicates must hold', () => {
+        registerAction({ id: 'p', label: 'P', scope: 'home', submenu: true }, 'shard.x');
+        // active child (home is active by default in the test state)
+        registerAction({ id: 'p:a', label: 'A', scope: 'home',
+            submenuOf: 'p', run: () => { } }, 'shard.x');
+        // inactive child (app scope, no active app)
+        registerAction({ id: 'p:b', label: 'B', scope: 'app',
+            submenuOf: 'p', run: () => { } }, 'shard.x');
+        const api = makeSh3Api({ callerKind: 'verb' });
+        const ids = api
+            .listActions({ submenuOf: 'p', activeOnly: true })
+            .map((d) => d.id);
+        expect(ids).toEqual(['p:a']);
+    });
+});

package/dist/sh3Runtime.svelte.d.ts

@@ -10,6 +10,8 @@ import type { ColorApi } from './color/api';
 import { type OpenContextMenuOpts, type OpenPaletteOpts } from './actions/listeners';
 import type { ActiveActionDescriptor } from './actions/types';
 import { type DispatchToTerminalResult } from './shell-shard/dispatch-to-terminal';
+import type { ViewportInfo, ViewportClass } from './viewport/types';
+import type { DrawerAnchor, DrawerStateMap } from './layout/compact/types';
 /**
  * The process-wide sh3 singleton exposed to shards and the sh3's own
  * internal code. Provides state zone creation and overlay managers.
@@ -39,6 +41,17 @@ export interface Sh3 {
     color: ColorApi;
     /** Actions facade — rebind keys, query bindings, open menus/palette. */
     actions: Sh3ActionsApi;
+    /**
+     * Reactive viewport classification. Subscribers fire on class change
+     * (desktop ↔ compact). Use `override(cls)` to pin a class for
+     * playgrounds and debug; pass null to restore auto-derivation.
+     */
+    readonly viewport: Sh3Viewport;
+    /**
+     * Compact-mode drawer surface controls. Inert on desktop — mutating
+     * methods throw rather than silently no-op so misuse is caught early.
+     */
+    readonly drawers: Sh3Drawers;
     /**
      * Dispatch `line` through a Terminal view's normal submit path. Used by
      * views outside a verb context (floating pickers, dialogs) to drive a
@@ -51,6 +64,29 @@ export interface Sh3 {
      */
     dispatchToTerminal(line: string): DispatchToTerminalResult;
 }
+/**
+ * Compact-mode drawer surface controls. Mutating methods throw on desktop
+ * so misuse surfaces as a loud error instead of a silent no-op.
+ */
+export interface Sh3Drawers {
+    readonly state: DrawerStateMap;
+    open(anchor: DrawerAnchor): void;
+    close(anchor: DrawerAnchor): void;
+    toggle(anchor: DrawerAnchor): void;
+    activate(anchor: DrawerAnchor, slotId: string): void;
+}
+/**
+ * Reactive viewport classification surface. See viewport/store.svelte.ts.
+ */
+export interface Sh3Viewport {
+    /** Reactive — read directly inside an effect, or use `subscribe()`. */
+    readonly current: ViewportInfo;
+    subscribe(cb: (i: ViewportInfo) => void): () => void;
+    /** Pin the class. Pass null to restore auto. Debug/playground only. */
+    override(cls: ViewportClass | null): void;
+    /** Currently-pinned override (null = auto). */
+    readonly pinned: ViewportClass | null;
+}
 /**
  * API for managing action bindings and triggering menus/palette
  * programmatically (e.g. from a future settings UI shard).

package/dist/sh3Runtime.svelte.js

@@ -28,6 +28,8 @@ import { setUserBindings, getLiveDispatcherState, onActiveChange as onActiveChan
 import { listActions, onActionsChange } from './actions/registry';
 import { listActiveFromEntries } from './actions/listActive';
 import { makeDispatchToTerminal } from './shell-shard/dispatch-to-terminal';
+import { viewportStore } from './viewport/store.svelte';
+import { drawerStore } from './layout/compact/drawerStore.svelte';
 const sh3Actions = {
     async rebind(appId, actionId, shortcut) {
         await saveUserBinding(appId, actionId, shortcut);
@@ -77,4 +79,35 @@ export const sh3 = {
     color: colorApi,
     actions: sh3Actions,
     dispatchToTerminal: makeDispatchToTerminal({ headless: false }),
+    viewport: {
+        get current() { return viewportStore.current; },
+        subscribe: (cb) => viewportStore.subscribe(cb),
+        override: (cls) => viewportStore.override(cls),
+        get pinned() { return viewportStore.pinned; },
+    },
+    drawers: {
+        get state() { return drawerStore.state; },
+        open: (anchor) => {
+            assertCompact('open');
+            drawerStore.open(anchor);
+        },
+        close: (anchor) => {
+            assertCompact('close');
+            drawerStore.close(anchor);
+        },
+        toggle: (anchor) => {
+            assertCompact('toggle');
+            drawerStore.toggle(anchor);
+        },
+        activate: (anchor, slotId) => {
+            assertCompact('activate');
+            drawerStore.activate(anchor, slotId);
+        },
+    },
 };
+function assertCompact(method) {
+    const cls = viewportStore.current.class;
+    if (cls !== 'compact') {
+        throw new Error(`Sh3.drawers.${method}: viewport class is "${cls}"; drawers exist only on compact`);
+    }
+}

package/dist/shards/activate.svelte.js

@@ -21,6 +21,8 @@ import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregiste
 import { makeSh3Api } from '../sh3Api/headless';
 import { createDocumentHandle, getTenantId, getDocumentBackend } from '../documents';
 import { fetchEnvState, putEnvState } from '../env/client';
+import { getEnvServerUrl } from '../env/index';
+import { apiFetch } from '../transport/apiFetch';
 import { isAdmin as checkIsAdmin } from '../auth/index';
 import { createZoneManager } from '../state/manage';
 import { PERMISSION_STATE_MANAGE } from '../state/types';
@@ -157,6 +159,14 @@ export async function activateShard(id, opts) {
             entry.cleanupFns.push(() => handle.dispose());
             return handle;
         },
+        fetch(path, init) {
+            const isAbsolute = path.startsWith('http://') || path.startsWith('https://');
+            if (isAbsolute)
+                return apiFetch(path, init);
+            const base = getEnvServerUrl();
+            const sep = path.startsWith('/') ? '' : '/';
+            return apiFetch(`${base}${sep}${path}`, init);
+        },
         env(defaults) {
             if (envState.proxy) {
                 console.warn(`[sh3] Shard "${id}" called ctx.env() more than once; extra calls are ignored.`);

package/dist/shards/ctx-fetch.test.d.ts

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