sh3-core 0.17.0 → 0.19.0

package/dist/chrome/MenuSheet.svelte.test.d.ts

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

package/dist/chrome/MenuSheet.svelte.test.js

@@ -0,0 +1,46 @@
+/*
+ * DOM smoke for MenuSheet — verifies open/closed rendering. The
+ * container/item resolution is exercised via the same model functions
+ * MenuBar uses; their unit tests cover the resolution semantics so
+ * this test only asserts the wrapper structure.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { mount, unmount, flushSync } from 'svelte';
+import MenuSheet from './MenuSheet.svelte';
+const MenuSheetAny = MenuSheet;
+let mounted = null;
+let host = null;
+afterEach(() => {
+    if (mounted) {
+        unmount(mounted);
+        mounted = null;
+    }
+    if (host) {
+        host.remove();
+        host = null;
+    }
+});
+describe('MenuSheet (dom)', () => {
+    it('renders nothing when closed', () => {
+        host = document.createElement('div');
+        document.body.appendChild(host);
+        mounted = mount(MenuSheetAny, {
+            target: host,
+            props: { open: false, onClose: () => { } },
+        });
+        flushSync();
+        expect(host.querySelector('[data-sh3-region="menu-sheet"]')).toBeNull();
+    });
+    it('renders a sheet with a Cancel button when open', () => {
+        host = document.createElement('div');
+        document.body.appendChild(host);
+        mounted = mount(MenuSheetAny, {
+            target: host,
+            props: { open: true, onClose: () => { } },
+        });
+        flushSync();
+        const sheet = host.querySelector('[data-sh3-region="menu-sheet"]');
+        expect(sheet).not.toBeNull();
+        expect(sheet.querySelector('.cancel').textContent).toContain('Cancel');
+    });
+});

package/dist/createShell.d.ts

@@ -22,5 +22,14 @@ export interface Sh3Config {
     target?: string | HTMLElement;
     /** Server base URL ('' for same-origin) */
     serverUrl?: string;
+    /**
+     * When true, override the local-owner short-circuit and run the
+     * full server-driven auth flow (boot config fetch, SignInWall when
+     * required) against `serverUrl`. Used by Tauri clients connecting
+     * to a remote sh3-server (e.g. Android), where Tauri presence makes
+     * `platform.localOwner` true even though authentication is server-
+     * gated.
+     */
+    remoteAuth?: boolean;
 }
 export declare function createShell(config?: Sh3Config): Promise<void>;

package/dist/createShell.js

@@ -10,8 +10,9 @@ import { mount, unmount } from 'svelte';
 import { Sh3 } from './index';
 import { registerShard, registerApp, bootstrap, bootstrapSatellite, __setBackend, setLocalOwner, } from './host';
 import { resolvePlatform } from './platform/index';
+import { apiFetch } from './transport/apiFetch';
 import { hydrateTokenOverrides } from './theme';
-import { __setEnvServerUrl } from './env/index';
+import { __setEnvServerUrl, getEnvServerUrl } from './env/index';
 import { __setActiveScope } from './documents/config';
 import { initFromBoot } from './auth/index';
 import SignInWall from './auth/SignInWall.svelte';
@@ -83,11 +84,13 @@ export async function createShell(config) {
         mount(SatelliteShell, { target, props: { payload: satellite.payload } });
         return;
     }
-    // 3. Fetch boot config (skip for local-owner platforms like Tauri/dev)
+    // 3. Fetch boot config (skip for purely-local owners; remoteAuth
+    //    forces it for cross-origin Tauri clients).
     let bootConfig = null;
-    if (!platform.localOwner) {
+    const useServerAuth = !platform.localOwner || (config === null || config === void 0 ? void 0 : config.remoteAuth) === true;
+    if (useServerAuth) {
         try {
-            const res = await fetch(`${sUrl}/api/boot`, { credentials: 'include' });
+            const res = await apiFetch(`${sUrl}/api/boot`);
             if (res.ok) {
                 bootConfig = await res.json();
             }
@@ -97,7 +100,7 @@ export async function createShell(config) {
         }
     }
     // 4. Auth decision point
-    if (platform.localOwner) {
+    if (platform.localOwner && !(config === null || config === void 0 ? void 0 : config.remoteAuth)) {
         // Local-owner (Tauri/dev): no auth, no sign-in, scope is 'local'.
         // setLocalOwner() already called above — admin is assumed.
         __setActiveScope('local');
@@ -110,7 +113,7 @@ export async function createShell(config) {
         if (!session && auth.required && !auth.guestAllowed) {
             await showSignInWall(target, bootConfig);
             // After successful sign-in, re-fetch boot config
-            const res = await fetch(`${sUrl}/api/boot`, { credentials: 'include' });
+            const res = await apiFetch(`${sUrl}/api/boot`);
             if (res.ok) {
                 bootConfig = await res.json();
                 initFromBoot(sUrl, bootConfig);
@@ -150,7 +153,17 @@ async function loadDiscoveredPackages(packages) {
         return;
     for (const pkg of packages) {
         try {
-            const res = await fetch(pkg.bundleUrl);
+            // Server returns server-relative paths like `/packages/<id>/client.js`.
+            // In a cross-origin Tauri client these resolve against the webview
+            // origin (`tauri://localhost`) instead of the configured server, so
+            // we get the SPA's index.html back and the loader chokes on `<`.
+            // Resolve against the active serverUrl and route through apiFetch
+            // for the cross-origin-safe transport + bearer header.
+            const isAbsolute = pkg.bundleUrl.startsWith('http://') || pkg.bundleUrl.startsWith('https://');
+            const base = getEnvServerUrl();
+            const sep = pkg.bundleUrl.startsWith('/') ? '' : '/';
+            const url = isAbsolute ? pkg.bundleUrl : `${base}${sep}${pkg.bundleUrl}`;
+            const res = await apiFetch(url);
             if (!res.ok) {
                 console.warn(`[sh3] Failed to fetch discovered package "${pkg.id}": HTTP ${res.status}`);
                 continue;

package/dist/createShell.remoteAuth.test.d.ts

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

package/dist/createShell.remoteAuth.test.js

@@ -0,0 +1,71 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+describe('createShell remoteAuth flag', () => {
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = globalThis.fetch;
+        vi.resetModules();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        vi.doUnmock('./platform/index');
+        vi.doUnmock('./host');
+    });
+    function shortCircuitAfterBoot() {
+        // Mock bootstrap so createShell throws right after the boot-config
+        // fetch we want to observe — and never reaches mount(Sh3, ...).
+        vi.doMock('./host', async () => {
+            const actual = await vi.importActual('./host');
+            return Object.assign(Object.assign({}, actual), { bootstrap: async () => {
+                    throw new Error('test-skip-bootstrap');
+                } });
+        });
+    }
+    it('fetches /api/boot when remoteAuth is true even if localOwner is detected', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (input) => {
+            calls.push(String(input));
+            return new Response(JSON.stringify({
+                version: '0.18.0',
+                tenantId: 't1',
+                auth: { required: false, guestAllowed: true, selfRegistration: false },
+                session: { token: 'tok', userId: 'u1', role: 'user', expiresAt: Number.MAX_SAFE_INTEGER },
+                user: { id: 'u1', username: 'u', displayName: 'U', role: 'user', createdAt: '', updatedAt: '' },
+            }), { status: 200, headers: { 'Content-Type': 'application/json' } });
+        });
+        vi.doMock('./platform/index', () => ({
+            resolvePlatform: async () => ({ backends: null, localOwner: true }),
+        }));
+        shortCircuitAfterBoot();
+        document.body.innerHTML = '<div id="app"></div>';
+        const { createShell } = await import('./createShell');
+        // The full boot pipeline (mount, bootstrap, etc.) may throw in this
+        // test env — we only care that the boot-config fetch was attempted.
+        try {
+            await createShell({ serverUrl: 'https://remote.example.com', remoteAuth: true });
+        }
+        catch (_a) {
+            // ignore — assertion below is the contract.
+        }
+        expect(calls.some(u => u === 'https://remote.example.com/api/boot')).toBe(true);
+    });
+    it('keeps the legacy localOwner short-circuit when remoteAuth is absent', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (input) => {
+            calls.push(String(input));
+            return new Response('ok');
+        });
+        vi.doMock('./platform/index', () => ({
+            resolvePlatform: async () => ({ backends: null, localOwner: true }),
+        }));
+        shortCircuitAfterBoot();
+        document.body.innerHTML = '<div id="app"></div>';
+        const { createShell } = await import('./createShell');
+        try {
+            await createShell({ serverUrl: '' });
+        }
+        catch (_a) {
+            // ignore — assertion below is the contract.
+        }
+        expect(calls.some(u => u.endsWith('/api/boot'))).toBe(false);
+    });
+});

package/dist/documents/http-backend.js

@@ -20,6 +20,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _HttpDocumentBackend_instances, _HttpDocumentBackend_baseUrl, _HttpDocumentBackend_apiKey, _HttpDocumentBackend_authHeaders;
+import { apiFetch } from '../transport/apiFetch';
 export class HttpDocumentBackend {
     /**
      * @param baseUrl - The server origin (e.g. 'http://localhost:3000' or window.location.origin).
@@ -36,7 +37,7 @@ export class HttpDocumentBackend {
     async read(tenantId, shardId, path) {
         var _a;
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}`;
-        const res = await fetch(url, { credentials: 'include' });
+        const res = await apiFetch(url, { credentials: 'include' });
         if (res.status === 404)
             return null;
         if (!res.ok)
@@ -50,45 +51,45 @@ export class HttpDocumentBackend {
     async write(tenantId, shardId, path, content) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}`;
         const headers = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this)), { 'Content-Type': typeof content === 'string' ? 'text/plain' : 'application/octet-stream' });
-        const res = await fetch(url, { method: 'PUT', headers, body: content, credentials: 'include' });
+        const res = await apiFetch(url, { method: 'PUT', headers, body: content, credentials: 'include' });
         if (!res.ok)
             throw new Error(`Document write failed: ${res.status}`);
     }
     async delete(tenantId, shardId, path) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}`;
-        const res = await fetch(url, { method: 'DELETE', headers: __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this), credentials: 'include' });
+        const res = await apiFetch(url, { method: 'DELETE', headers: __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this), credentials: 'include' });
         if (!res.ok)
             throw new Error(`Document delete failed: ${res.status}`);
     }
     async list(tenantId, shardId) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}`;
-        const res = await fetch(url, { credentials: 'include' });
+        const res = await apiFetch(url, { credentials: 'include' });
         if (!res.ok)
             throw new Error(`Document list failed: ${res.status}`);
         return res.json();
     }
     async exists(tenantId, shardId, path) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}`;
-        const res = await fetch(url, { method: 'HEAD', credentials: 'include' });
+        const res = await apiFetch(url, { method: 'HEAD', credentials: 'include' });
         return res.ok;
     }
     async listAllShards(tenantId) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/_shards`;
-        const res = await fetch(url, { credentials: 'include' });
+        const res = await apiFetch(url, { credentials: 'include' });
         if (!res.ok)
             throw new Error(`listAllShards failed: ${res.status}`);
         return res.json();
     }
     async listAllDocuments(tenantId) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/_all`;
-        const res = await fetch(url, { credentials: 'include' });
+        const res = await apiFetch(url, { credentials: 'include' });
         if (!res.ok)
             throw new Error(`listAllDocuments failed: ${res.status}`);
         return res.json();
     }
     async readMeta(tenantId, shardId, path) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}?meta=1`;
-        const res = await fetch(url, { credentials: 'include' });
+        const res = await apiFetch(url, { credentials: 'include' });
         if (!res.ok)
             throw new Error(`readMeta failed: ${res.status}`);
         const body = await res.json();
@@ -101,7 +102,7 @@ export class HttpDocumentBackend {
         const body = typeof choice === 'string'
             ? { choice }
             : { choice: choice.origin };
-        const res = await fetch(url, {
+        const res = await apiFetch(url, {
             method: 'POST',
             credentials: 'include',
             headers: Object.assign(Object.assign({}, __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this)), { 'Content-Type': 'application/json' }),
@@ -112,7 +113,7 @@ export class HttpDocumentBackend {
     }
     async readBranch(tenantId, shardId, path, origin) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}/branch?origin=${encodeURIComponent(origin)}`;
-        const res = await fetch(url, { credentials: 'include' });
+        const res = await apiFetch(url, { credentials: 'include' });
         if (res.status === 404)
             return null;
         if (!res.ok)
@@ -122,7 +123,7 @@ export class HttpDocumentBackend {
     async rename(tenantId, shardId, oldPath, newPath) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${oldPath}/rename`;
         const headers = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this)), { 'Content-Type': 'application/json' });
-        const res = await fetch(url, {
+        const res = await apiFetch(url, {
             method: 'POST',
             headers,
             body: JSON.stringify({ to: newPath }),

package/dist/env/client.js

@@ -3,6 +3,7 @@
  * from the server.
  */
 import { getAuthHeader, isAdmin } from '../auth/index';
+import { apiFetch } from '../transport/apiFetch';
 /** Server base URL, set once during configuration. */
 let serverUrl = '';
 /** Configure the server URL for env state operations. */
@@ -18,7 +19,9 @@ export function getEnvServerUrl() {
  * Returns an empty object if the server has no stored state.
  */
 export async function fetchEnvState(shardId) {
-    const res = await fetch(`${serverUrl}/api/env-state/${encodeURIComponent(shardId)}`);
+    const res = await apiFetch(`${serverUrl}/api/env-state/${encodeURIComponent(shardId)}`, {
+        credentials: 'omit',
+    });
     if (!res.ok) {
         console.warn(`[sh3] Failed to fetch env state for "${shardId}": HTTP ${res.status}`);
         return {};
@@ -38,10 +41,11 @@ export async function putEnvState(shardId, state) {
     const headers = { 'Content-Type': 'application/json' };
     if (auth)
         headers['Authorization'] = auth;
-    const res = await fetch(`${serverUrl}/api/env-state/${encodeURIComponent(shardId)}`, {
+    const res = await apiFetch(`${serverUrl}/api/env-state/${encodeURIComponent(shardId)}`, {
         method: 'PUT',
         headers,
         body: JSON.stringify(state),
+        credentials: 'omit',
     });
     if (!res.ok) {
         const body = await res.json().catch(() => ({}));
@@ -73,10 +77,11 @@ export async function serverInstallPackage(manifest, clientBundle, serverBundle)
     const headers = {};
     if (auth)
         headers['Authorization'] = auth;
-    const res = await fetch(`${serverUrl}/api/packages/install`, {
+    const res = await apiFetch(`${serverUrl}/api/packages/install`, {
         method: 'POST',
         headers,
         body: form,
+        credentials: 'omit',
     });
     if (!res.ok) {
         let body = {};
@@ -104,10 +109,11 @@ export async function serverUninstallPackage(id) {
     const headers = { 'Content-Type': 'application/json' };
     if (auth)
         headers['Authorization'] = auth;
-    const res = await fetch(`${serverUrl}/api/packages/uninstall`, {
+    const res = await apiFetch(`${serverUrl}/api/packages/uninstall`, {
         method: 'POST',
         headers,
         body: JSON.stringify({ id }),
+        credentials: 'omit',
     });
     if (!res.ok) {
         const body = await res.json().catch(() => ({}));
@@ -118,7 +124,7 @@ export async function serverUninstallPackage(id) {
  * Fetch the list of packages installed on the server.
  */
 export async function fetchServerPackages() {
-    const res = await fetch(`${serverUrl}/api/packages`);
+    const res = await apiFetch(`${serverUrl}/api/packages`, { credentials: 'omit' });
     if (!res.ok)
         return [];
     return await res.json();

package/dist/files/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * A reference to a document passed to file handler callbacks and app launch args.
+ */
+export interface FileRef {
+    path: string;
+    tenantId: string;
+    /** True when the file was identified as binary content. */
+    binary: boolean;
+}
+/** A single header pattern rule. */
+export type FileHandlerPattern = {
+    type: 'startsWith';
+    value: string;
+} | {
+    type: 'includes';
+    value: string;
+} | {
+    type: 'regex';
+    pattern: string;
+    flags?: string;
+};
+/**
+ * Optional header-based disambiguation used when multiple handlers share
+ * an extension. The dispatcher reads the file head and tests these rules
+ * to narrow the candidate set.
+ */
+export interface FileHandlerHeader {
+    /**
+     * Max bytes/chars to read from the file head.
+     * @default 256
+     */
+    readBytes?: number;
+    /**
+     * Declarative patterns tested in order — first match wins.
+     * Evaluated before `predicate`.
+     */
+    patterns?: FileHandlerPattern[];
+    /**
+     * Escape-hatch for logic that cannot be expressed as patterns.
+     * Receives `string` for text files, `Uint8Array` for binary.
+     */
+    predicate?: (header: string | Uint8Array) => boolean;
+}
+/** File matching rules for a handler. */
+export interface FileHandlerMatch {
+    /**
+     * File extensions this handler claims, e.g. `['.svg', '.svgz']`.
+     * Compared case-insensitively by the dispatcher.
+     */
+    extensions: string[];
+    /**
+     * When true, this handler accepts binary files.
+     * @default false
+     */
+    binary?: boolean;
+    /** Optional header rules for disambiguation when extensions collide. */
+    header?: FileHandlerHeader;
+}
+/**
+ * How the dispatcher should open the matched file.
+ *
+ * - `view` — the shard's callback is called; the shard mounts the view
+ *   itself via its own `ctx` closure. Placement is the dispatcher's concern.
+ * - `app` — the dispatcher calls `launchApp(appId, { args: { file } })`.
+ *   The app reads `ctx.args.file` in `activate()`.
+ */
+export type FileHandlerOpen = {
+    type: 'view';
+    /**
+     * Called by the dispatcher with the resolved file. The shard closes
+     * over its own ShardContext — it wires the file to internal state and
+     * mounts its view using its existing shell access.
+     */
+    open: (file: FileRef) => void | Promise<void>;
+} | {
+    type: 'app';
+    /** Id of the app to launch. Must be registered. */
+    appId: string;
+};
+/**
+ * Descriptor registered at contribution point `sh3.file-handler`.
+ *
+ * @example
+ * ```ts
+ * ctx.contributions.register('sh3.file-handler', {
+ *   label: 'SVG Viewer',
+ *   match: { extensions: ['.svg'] },
+ *   open: {
+ *     type: 'view',
+ *     open: (file) => { pendingFile.set(file); shell.openViewInCurrentLayout(viewId); },
+ *   },
+ * } satisfies FileHandlerDescriptor);
+ * ```
+ */
+export interface FileHandlerDescriptor {
+    /** Human-readable name shown in "open with" UI. */
+    label: string;
+    match: FileHandlerMatch;
+    open: FileHandlerOpen;
+    /**
+     * Tie-breaking priority. Higher wins when multiple handlers match after
+     * extension + header filtering.
+     * @default 0
+     */
+    priority?: number;
+}

package/dist/files/types.js

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

package/dist/gestures/gestureRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { GestureOptions, GestureHandle } from './types';
+export interface GestureRegistry {
+    register(opts: GestureOptions): GestureHandle;
+    destroy(): void;
+}
+export declare function createGestureRegistry(defaultContainer: HTMLElement | null): GestureRegistry;