sh3-core 0.17.0 → 0.19.0

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

@@ -8,7 +8,7 @@ import type { Sh3Api } from '../verbs/types';
 import type { ShardContextKeys } from '../keys/types';
 import type { ContributionsApi } from '../contributions/types';
 import type { ActionsApi } from '../actions/types';
-import type { TreeRootRef } from '../layout/types';
+import type { TreeRootRef, SlotRole } from '../layout/types';
 export { PERMISSION_KEYS_MINT, type ShardContextKeys, type ApiKeyPublic, type MintOpts, ScopeEscalationError, ConsentDeniedError } from '../keys/types';
 /**
  * The object returned by `ViewFactory.mount`. The framework calls
@@ -38,6 +38,14 @@ export interface ViewHandle {
     closable?: boolean | {
         canClose(): Promise<boolean>;
     };
+    /**
+     * View-level slot-role default. The compact renderer reads this when
+     * the containing slot's `role` is unset; slot-level always wins.
+     *
+     * Lets a view declare "I'm a sidebar by nature" without forcing the
+     * app author to know. See `layout/compact/resolveRole.ts`.
+     */
+    defaultRole?: SlotRole;
 }
 /**
  * Context passed to `ViewFactory.mount` so the view knows which layout
@@ -197,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/tokens.css

@@ -79,8 +79,9 @@
    * source of truth for the layer stack. No component outside the overlay
    * layer managers is permitted to write a z-index.
    */
-  --sh3-z-layer-0: 0;   /* docked layout (content area) */
-  --sh3-z-layer-1: 100; /* floating panels (deferred)   */
+  --sh3-z-layer-0: 0;   /* docked layout (content area)         */
+  --sh3-z-layer-drawers: 50; /* compact-mode drawer surfaces     */
+  --sh3-z-layer-1: 100; /* floating panels (deferred)           */
   --sh3-z-layer-2: 200; /* drag preview                 */
   --sh3-z-layer-3: 300; /* popups, context menus        */
   --sh3-z-layer-4: 400; /* modals                       */

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

package/dist/transport/apiFetch.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+describe('apiFetch', () => {
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = globalThis.fetch;
+        vi.resetModules();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('uses global fetch with credentials:include when Tauri plugin-http is unavailable', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (input, init) => {
+            calls.push([input, init]);
+            return new Response('ok');
+        });
+        const { apiFetch } = await import('./apiFetch');
+        const res = await apiFetch('https://example.com/api/foo', { method: 'GET' });
+        expect(await res.text()).toBe('ok');
+        expect(calls).toHaveLength(1);
+        const [input, init] = calls[0];
+        expect(input).toBe('https://example.com/api/foo');
+        expect(init.credentials).toBe('include');
+        expect(init.method).toBe('GET');
+    });
+    it('lets caller-provided credentials override the default', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (input, init) => {
+            calls.push([input, init]);
+            return new Response('ok');
+        });
+        const { apiFetch } = await import('./apiFetch');
+        await apiFetch('https://example.com/api/foo', { credentials: 'omit' });
+        const [, init] = calls[0];
+        expect(init.credentials).toBe('omit');
+    });
+});

package/dist/transport/authToken.d.ts

@@ -0,0 +1,2 @@
+export declare function setAuthToken(value: string | null): void;
+export declare function getAuthToken(): string | null;

package/dist/transport/authToken.js

@@ -0,0 +1,53 @@
+/*
+ * Auth-token store used by `apiFetch` to attach `Authorization: Bearer
+ * <token>` to every request when a session exists.
+ *
+ * The browser auth flow relies on Set-Cookie + same-origin requests to
+ * keep the session alive. That breaks down for cross-origin Tauri
+ * clients (e.g. Android): the WebView's origin is `tauri://localhost`
+ * and the sh3-server lives on a different domain, so the session
+ * cookie is treated as cross-site and dropped under SameSite=Lax. On
+ * top of that, `@tauri-apps/plugin-http` (reqwest under the hood)
+ * doesn't enable a persistent cookie store by default, so even if
+ * SameSite weren't an issue cookies wouldn't survive between calls.
+ *
+ * Carrying the session token in a header sidesteps both problems.
+ * `auth.svelte.ts` populates this store after login/register/initFromBoot
+ * and clears it on logout. The token is mirrored to localStorage so an
+ * app restart doesn't dump the user back at the sign-in wall.
+ */
+const KEY = 'sh3:authToken';
+let token = null;
+let restored = false;
+function restore() {
+    if (restored)
+        return;
+    restored = true;
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        token = localStorage.getItem(KEY);
+    }
+    catch (_a) {
+        token = null;
+    }
+}
+export function setAuthToken(value) {
+    restored = true;
+    token = value;
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        if (value)
+            localStorage.setItem(KEY, value);
+        else
+            localStorage.removeItem(KEY);
+    }
+    catch (_a) {
+        // localStorage may be disabled (private browsing); in-memory copy still works.
+    }
+}
+export function getAuthToken() {
+    restore();
+    return token;
+}

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

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

package/dist/transport/authToken.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it, beforeEach, vi } from 'vitest';
+describe('authToken', () => {
+    beforeEach(() => {
+        vi.resetModules();
+        if (typeof localStorage !== 'undefined')
+            localStorage.clear();
+    });
+    it('returns null when nothing stored', async () => {
+        const { getAuthToken } = await import('./authToken');
+        expect(getAuthToken()).toBeNull();
+    });
+    it('round-trips set/get', async () => {
+        const { setAuthToken, getAuthToken } = await import('./authToken');
+        setAuthToken('sh3s_deadbeef');
+        expect(getAuthToken()).toBe('sh3s_deadbeef');
+    });
+    it('persists across module re-imports via localStorage', async () => {
+        const first = await import('./authToken');
+        first.setAuthToken('sh3s_persisted');
+        vi.resetModules();
+        const second = await import('./authToken');
+        expect(second.getAuthToken()).toBe('sh3s_persisted');
+    });
+    it('clear removes from storage', async () => {
+        const { setAuthToken, getAuthToken } = await import('./authToken');
+        setAuthToken('sh3s_x');
+        setAuthToken(null);
+        expect(getAuthToken()).toBeNull();
+        vi.resetModules();
+        const reloaded = await import('./authToken');
+        expect(reloaded.getAuthToken()).toBeNull();
+    });
+});

package/dist/verbs/types.d.ts

@@ -128,11 +128,14 @@ export interface Sh3Api {
         scrollback: ScrollbackEntry[];
     }>;
     /**
-     * Read-only snapshot of every action registered across every shard. Pass
-     * { activeOnly: true } to filter to currently-dispatchable actions.
+     * Read-only snapshot of every action registered across every shard.
+     * - `activeOnly`: filter to currently-dispatchable actions.
+     * - `submenuOf`: restrict to children of the named parent action id
+     *   (mirrors the palette sub-drill filter).
      */
     listActions(opts?: {
         activeOnly?: boolean;
+        submenuOf?: string;
     }): ActionDescriptor[];
     /**
      * Programmatically dispatch a registered action by id. Same semantics as

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.17.0";
+export declare const VERSION = "0.19.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.17.0';
+export const VERSION = '0.19.0';

package/dist/viewport/classify.d.ts

@@ -0,0 +1,8 @@
+import type { ViewportClass } from './types';
+export interface ClassifyInput {
+    width: number;
+    coarsePointer: boolean;
+    noHover: boolean;
+    dpr: number;
+}
+export declare function classify(i: ClassifyInput): ViewportClass;

package/dist/viewport/classify.js

@@ -0,0 +1,20 @@
+/*
+ * classify — derives the viewport class from multi-signal input.
+ *
+ * Why multi-signal: a 6.7" phone reports ~393 CSS px wide *with* coarse
+ * pointer + high DPR; a narrow desktop window reports the same width
+ * *with* fine pointer + DPR 1-2. CSS pixels alone undercount physical
+ * compactness on high-DPI mobile, so width is one signal among three.
+ *
+ * The thresholds (720, 1100) are not load-bearing — they're tunable in
+ * a single place. Adjust with a corresponding test row.
+ */
+export function classify(i) {
+    if (i.coarsePointer && i.noHover)
+        return 'compact';
+    if (i.width < 720)
+        return 'compact';
+    if (i.coarsePointer && i.dpr >= 2 && i.width < 1100)
+        return 'compact';
+    return 'desktop';
+}

package/dist/viewport/classify.test.d.ts

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

package/dist/viewport/classify.test.js

@@ -0,0 +1,32 @@
+/*
+ * Table-driven tests for the viewport classifier. Each row is a real
+ * device (or a deliberately-chosen edge case) with the signal tuple
+ * expected from a real browser/matchMedia in that device's typical
+ * orientation.
+ */
+import { describe, it, expect } from 'vitest';
+import { classify } from './classify';
+const ROWS = [
+    { name: 'phone portrait', width: 393, coarsePointer: true, noHover: true, dpr: 3, expected: 'compact' },
+    { name: 'phone landscape', width: 852, coarsePointer: true, noHover: true, dpr: 3, expected: 'compact' },
+    { name: 'tablet portrait', width: 768, coarsePointer: true, noHover: true, dpr: 2, expected: 'compact' },
+    { name: 'tablet landscape', width: 1024, coarsePointer: true, noHover: true, dpr: 2, expected: 'compact' },
+    { name: 'desktop wide', width: 1920, coarsePointer: false, noHover: false, dpr: 1, expected: 'desktop' },
+    { name: 'desktop narrow window', width: 700, coarsePointer: false, noHover: false, dpr: 1, expected: 'compact' },
+    { name: 'iPad with mouse attached', width: 1024, coarsePointer: false, noHover: false, dpr: 2, expected: 'desktop' },
+    { name: 'small laptop', width: 1366, coarsePointer: false, noHover: false, dpr: 1, expected: 'desktop' },
+    { name: 'phone with stylus (hover ok)', width: 412, coarsePointer: true, noHover: false, dpr: 3, expected: 'compact' },
+];
+describe('classify', () => {
+    for (const row of ROWS) {
+        it(`${row.name} → ${row.expected}`, () => {
+            const result = classify({
+                width: row.width,
+                coarsePointer: row.coarsePointer,
+                noHover: row.noHover,
+                dpr: row.dpr,
+            });
+            expect(result).toBe(row.expected);
+        });
+    }
+});

package/dist/viewport/store.browser.test.d.ts

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

package/dist/viewport/store.browser.test.js

@@ -0,0 +1,33 @@
+/*
+ * Real-signal viewport classification — boots the viewport store under
+ * Chromium and asserts initial class + override behavior. happy-dom's
+ * matchMedia stub is shallow, so this is the contract pin against a
+ * real browser engine.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { viewportStore } from './store.svelte';
+beforeEach(() => {
+    viewportStore.__reset();
+});
+describe('viewport store under real browser', () => {
+    it('returns a viewport class consistent with the test runner window', () => {
+        const info = viewportStore.current;
+        expect(info.class).toMatch(/desktop|compact/);
+        expect(info.width).toBeGreaterThan(0);
+        expect(info.height).toBeGreaterThan(0);
+    });
+    it('override(compact) immediately flips class', () => {
+        const fires = [];
+        const unsub = viewportStore.subscribe((i) => fires.push(i.class));
+        viewportStore.override('compact');
+        expect(viewportStore.current.class).toBe('compact');
+        expect(fires).toContain('compact');
+        unsub();
+    });
+    it('override(null) restores auto-derived class', () => {
+        viewportStore.override('compact');
+        expect(viewportStore.pinned).toBe('compact');
+        viewportStore.override(null);
+        expect(viewportStore.pinned).toBeNull();
+    });
+});

package/dist/viewport/store.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { ViewportClass, ViewportInfo } from './types';
+export declare const viewportStore: {
+    readonly current: ViewportInfo;
+    subscribe(cb: (i: ViewportInfo) => void): () => void;
+    override(cls: ViewportClass | null): void;
+    readonly pinned: ViewportClass | null;
+    /** Test-only reset hook. Not exported from index.ts. */
+    __reset(): void;
+};

package/dist/viewport/store.svelte.js

@@ -0,0 +1,71 @@
+/*
+ * viewport store — reactive ViewportInfo with subscribe + override.
+ *
+ * Subscribes to window.resize, screen.orientation.change, and matchMedia
+ * change events for `pointer: coarse` / `hover: none`. Re-runs classify(),
+ * notifies subscribers only on class change (not every resize tick).
+ *
+ * Module is loaded eagerly by createShell, but the listener-wiring branch
+ * is gated on `typeof window` so node-only test runs don't crash.
+ */
+import { classify } from './classify';
+let pinnedClass = $state(null);
+const subscribers = new Set();
+function read() {
+    if (typeof window === 'undefined') {
+        return { class: 'desktop', width: 1920, height: 1080, coarsePointer: false, noHover: false, dpr: 1 };
+    }
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    const coarsePointer = window.matchMedia('(pointer: coarse)').matches;
+    const noHover = window.matchMedia('(hover: none)').matches;
+    const dpr = window.devicePixelRatio;
+    const cls = pinnedClass !== null && pinnedClass !== void 0 ? pinnedClass : classify({ width, coarsePointer, noHover, dpr });
+    return { class: cls, width, height, coarsePointer, noHover, dpr };
+}
+let cached = $state(read());
+function recompute() {
+    const next = read();
+    const prevClass = cached.class;
+    cached = next;
+    if (next.class !== prevClass) {
+        for (const cb of subscribers)
+            cb(next);
+    }
+}
+if (typeof window !== 'undefined') {
+    window.addEventListener('resize', recompute);
+    window.matchMedia('(pointer: coarse)').addEventListener('change', recompute);
+    window.matchMedia('(hover: none)').addEventListener('change', recompute);
+    if (typeof screen !== 'undefined' && screen.orientation) {
+        screen.orientation.addEventListener('change', recompute);
+    }
+}
+export const viewportStore = {
+    get current() {
+        return cached;
+    },
+    subscribe(cb) {
+        subscribers.add(cb);
+        return () => { subscribers.delete(cb); };
+    },
+    override(cls) {
+        if (pinnedClass === cls)
+            return;
+        pinnedClass = cls;
+        recompute();
+        // recompute only fires subscribers on class change. If override pins
+        // to the same class as the auto-derived one, the visible class doesn't
+        // change. Force-fire so consumers re-read the override state.
+        for (const cb of subscribers)
+            cb(cached);
+    },
+    get pinned() {
+        return pinnedClass;
+    },
+    /** Test-only reset hook. Not exported from index.ts. */
+    __reset() {
+        pinnedClass = null;
+        subscribers.clear();
+    },
+};

package/dist/viewport/store.svelte.test.d.ts

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

package/dist/viewport/store.svelte.test.js

@@ -0,0 +1,54 @@
+/*
+ * DOM tests for the viewport store. happy-dom's matchMedia stub returns
+ * { matches: false, addEventListener, removeEventListener } so we can
+ * verify the wiring without driving the real browser engine.
+ *
+ * These tests intentionally use the store's __reset hook between cases
+ * to isolate subscriber state.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { viewportStore } from './store.svelte';
+describe('viewport store (dom)', () => {
+    beforeEach(() => {
+        viewportStore.__reset();
+    });
+    it('current returns a ViewportInfo with shape', () => {
+        const info = viewportStore.current;
+        expect(info.class).toMatch(/desktop|compact/);
+        expect(typeof info.width).toBe('number');
+        expect(typeof info.height).toBe('number');
+    });
+    it('override(compact) flips class to compact', () => {
+        viewportStore.override('compact');
+        expect(viewportStore.current.class).toBe('compact');
+        expect(viewportStore.pinned).toBe('compact');
+    });
+    it('override(null) restores pinned to null', () => {
+        viewportStore.override('compact');
+        viewportStore.override(null);
+        expect(viewportStore.pinned).toBeNull();
+    });
+    it('subscribers fire on class change via override', () => {
+        const fires = [];
+        const unsub = viewportStore.subscribe((i) => fires.push(i.class));
+        viewportStore.override('compact');
+        expect(fires).toContain('compact');
+        unsub();
+    });
+    it('subscribers fire on override even when class does not change', () => {
+        // Auto-class on happy-dom is desktop (default width 1024 + fine pointer).
+        // override('desktop') should still fire so consumers see pin state change.
+        const fires = [];
+        const unsub = viewportStore.subscribe((i) => fires.push(i.class));
+        viewportStore.override('desktop');
+        expect(fires.length).toBeGreaterThan(0);
+        unsub();
+    });
+    it('unsubscribe stops further notifications', () => {
+        const fires = [];
+        const unsub = viewportStore.subscribe((i) => fires.push(i.class));
+        unsub();
+        viewportStore.override('compact');
+        expect(fires).toEqual([]);
+    });
+});

package/dist/viewport/types.d.ts

@@ -0,0 +1,9 @@
+export type ViewportClass = 'desktop' | 'compact';
+export interface ViewportInfo {
+    class: ViewportClass;
+    width: number;
+    height: number;
+    coarsePointer: boolean;
+    noHover: boolean;
+    dpr: number;
+}

package/dist/viewport/types.js

@@ -0,0 +1,6 @@
+/*
+ * Viewport class types. The classifier (./classify.ts) is pure; the
+ * store (./store.svelte.ts) wires it to matchMedia and exposes a
+ * reactive ViewportInfo via Sh3.viewport.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "type": "module",
   "files": [
     "dist"