sh3-core 0.17.2 → 0.19.0

package/dist/layout/types.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { LAYOUT_SCHEMA_VERSION } from './types';
+describe('TabsNode.wrap', () => {
+    it('accepts the optional wrap field', () => {
+        const tabs = {
+            type: 'tabs',
+            tabs: [{ slotId: 's1', viewId: null, label: 'A' }],
+            activeTab: 0,
+            wrap: true,
+        };
+        expect(tabs.wrap).toBe(true);
+    });
+    it('defaults to undefined (consumers treat as false)', () => {
+        const tabs = {
+            type: 'tabs',
+            tabs: [{ slotId: 's1', viewId: null, label: 'A' }],
+            activeTab: 0,
+        };
+        expect(tabs.wrap).toBeUndefined();
+    });
+});
+describe('LAYOUT_SCHEMA_VERSION', () => {
+    it('is 6 (bumped for TabsNode.wrap)', () => {
+        expect(LAYOUT_SCHEMA_VERSION).toBe(6);
+    });
+});

package/dist/overlays/ModalFrame.svelte

@@ -35,19 +35,21 @@
     close,
     boxStyle,
     onBackdropClick,
+    initialFocus = true,
   }: {
     Content: Component<Record<string, unknown>>;
     contentProps: Record<string, unknown>;
     close: () => void;
     boxStyle?: string;
     onBackdropClick?: () => void;
+    initialFocus?: boolean;
   } = $props();
 
   let box: HTMLDivElement;
 
   $effect(() => {
     if (!box) return;
-    return createFocusTrap(box);
+    return createFocusTrap(box, { initialFocus });
   });
 
   function handleFrameClick(ev: MouseEvent): void {

package/dist/overlays/ModalFrame.svelte.d.ts

@@ -5,6 +5,7 @@ type $$ComponentProps = {
     close: () => void;
     boxStyle?: string;
     onBackdropClick?: () => void;
+    initialFocus?: boolean;
 };
 declare const ModalFrame: Component<$$ComponentProps, {}, "">;
 type ModalFrame = ReturnType<typeof ModalFrame>;

package/dist/overlays/floatDismiss.js

@@ -12,11 +12,16 @@
  * own action handlers fire on `click`/`pointerup` and are unaffected.
  */
 import { floatManager } from './float';
+import { getOwner } from '../gestures';
 const registry = new Map();
 let listenerAttached = false;
 function onDocumentPointerDown(event) {
     if (registry.size === 0)
         return;
+    // Skip dismiss if a gesture has claimed this pointer — a swipe or drag
+    // is in progress and this pointerdown is not a real outside-click.
+    if (getOwner(event.pointerId))
+        return;
     const target = event.target;
     if (!target)
         return;

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

@@ -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/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 {};

package/dist/shards/ctx-fetch.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { __setDocumentBackend, __setTenantId } from '../documents/config';
+import { __setEnvServerUrl } from '../env/index';
+import { registerShard, activateShard, __resetShardRegistryForTest, } from './activate.svelte';
+import { __resetViewRegistryForTest } from './registry';
+describe('ctx.fetch', () => {
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = globalThis.fetch;
+        __resetShardRegistryForTest();
+        __resetViewRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-test');
+        __setEnvServerUrl('https://example.com');
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        __setEnvServerUrl('');
+    });
+    it('resolves relative paths against the configured serverUrl', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (input) => {
+            calls.push(String(input));
+            return new Response('ok');
+        });
+        let captured = null;
+        registerShard({
+            manifest: { id: 'test', label: 'test', version: '0.0.0', views: [] },
+            activate(ctx) { captured = ctx; },
+        });
+        await activateShard('test');
+        await captured.fetch('/api/foo');
+        expect(calls[0]).toBe('https://example.com/api/foo');
+    });
+    it('passes absolute URLs through unchanged', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (input) => {
+            calls.push(String(input));
+            return new Response('ok');
+        });
+        let captured = null;
+        registerShard({
+            manifest: { id: 'test', label: 'test', version: '0.0.0', views: [] },
+            activate(ctx) { captured = ctx; },
+        });
+        await activateShard('test');
+        await captured.fetch('https://other.example.com/api/bar');
+        expect(calls[0]).toBe('https://other.example.com/api/bar');
+    });
+    it('prepends a slash to bare relative paths', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (input) => {
+            calls.push(String(input));
+            return new Response('ok');
+        });
+        let captured = null;
+        registerShard({
+            manifest: { id: 'test', label: 'test', version: '0.0.0', views: [] },
+            activate(ctx) { captured = ctx; },
+        });
+        await activateShard('test');
+        await captured.fetch('api/baz');
+        expect(calls[0]).toBe('https://example.com/api/baz');
+    });
+});

package/dist/shards/types.d.ts

@@ -205,6 +205,19 @@ export interface ShardContext {
     registerVerb(verb: Verb): void;
     /** Obtain a file-oriented document handle scoped to this shard. */
     documents(options: DocumentHandleOptions): DocumentHandle;
+    /**
+     * Cross-origin-safe HTTP helper. Resolves relative `/api/...` paths
+     * against the configured serverUrl. In Tauri, routes through
+     * @tauri-apps/plugin-http (no browser CORS, cookies via reqwest).
+     * On web, behaves like `fetch` with `credentials: 'include'`.
+     *
+     * Server-shards must use this instead of global `fetch` to remain
+     * compatible with cross-origin clients (e.g. Tauri Android).
+     *
+     * @param path - Relative `/api/...` path or fully-qualified URL.
+     * @param init - Standard RequestInit.
+     */
+    fetch(path: string, init?: RequestInit): Promise<Response>;
     /**
      * Declare environment state for this shard and receive a hydrated snapshot.
      * Env state is server-authoritative, fetched once at activation, and

package/dist/transport/apiFetch.d.ts

@@ -0,0 +1 @@
+export declare function apiFetch(url: string, init?: RequestInit): Promise<Response>;

package/dist/transport/apiFetch.js

@@ -0,0 +1,65 @@
+/*
+ * apiFetch — single source of truth for HTTP calls against the
+ * configured sh3-server, transparently using Tauri's plugin-http
+ * when running inside a Tauri webview.
+ *
+ * Browser fetch enforces CORS and respects SameSite cookie rules,
+ * which breaks cross-origin requests from a Tauri webview at e.g.
+ * `tauri://localhost` to a remote sh3-server. plugin-http (reqwest
+ * under the hood) is not subject to browser CORS and uses a
+ * per-host cookie store, so existing same-origin auth keeps working
+ * across origins.
+ *
+ * The plugin-http import is dynamic and behind try/catch — same
+ * defensive pattern as `platform/index.ts`. Vite code-splits it
+ * into a Tauri-only chunk that never loads in web builds.
+ */
+import { getAuthToken } from './authToken';
+let tauriFetch = null;
+let tauriProbed = false;
+function inTauriRuntime() {
+    // The plugin's fetch implementation calls into IPC via window.__TAURI__,
+    // so the *package being installed* is not enough — we have to be running
+    // inside a Tauri webview where these globals are injected.
+    if (typeof window === 'undefined')
+        return false;
+    return '__TAURI_INTERNALS__' in window || '__TAURI__' in window;
+}
+async function getTauriFetch() {
+    if (tauriProbed)
+        return tauriFetch;
+    tauriProbed = true;
+    if (!inTauriRuntime())
+        return null;
+    try {
+        // Static analysis is skipped so Vite/svelte-package don't try to bundle
+        // the optional Tauri-only dependency in pure-web builds.
+        const specifier = '@tauri-apps/plugin-http';
+        const mod = await import(/* @vite-ignore */ specifier);
+        tauriFetch = mod.fetch;
+    }
+    catch (_a) {
+        tauriFetch = null;
+    }
+    return tauriFetch;
+}
+export async function apiFetch(url, init) {
+    var _a;
+    // Inject Authorization: Bearer <session-token> if a session is active
+    // and the caller didn't already supply one. Cookies don't survive the
+    // cross-origin hop (SameSite=Lax + plugin-http has no cookie store),
+    // so the header carries the session for both transports uniformly.
+    const token = getAuthToken();
+    let finalInit = init !== null && init !== void 0 ? init : {};
+    if (token) {
+        const headers = new Headers((_a = finalInit.headers) !== null && _a !== void 0 ? _a : {});
+        if (!headers.has('Authorization')) {
+            headers.set('Authorization', `Bearer ${token}`);
+            finalInit = Object.assign(Object.assign({}, finalInit), { headers });
+        }
+    }
+    const tf = await getTauriFetch();
+    if (tf)
+        return tf(url, finalInit);
+    return fetch(url, Object.assign({ credentials: 'include' }, finalInit));
+}

package/dist/transport/apiFetch.test.d.ts

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