sh3-core 0.17.2 → 0.19.0

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;

package/dist/gestures/gestureRegistry.js

@@ -0,0 +1,190 @@
+import { claim, revoke } from './pointerClaim';
+let _nextId = 0;
+function nextId() { return `sh3:gesture:${_nextId++}`; }
+function ancestorCount(el) {
+    let n = 0;
+    let cur = el;
+    while (cur) {
+        n++;
+        cur = cur.parentElement;
+    }
+    return n;
+}
+function activeModifiers(e) {
+    const mods = [];
+    if (e.ctrlKey)
+        mods.push('Control');
+    if (e.shiftKey)
+        mods.push('Shift');
+    if (e.altKey)
+        mods.push('Alt');
+    if (e.metaKey)
+        mods.push('Meta');
+    return mods;
+}
+function modifiersMatch(required, active) {
+    if (required.length !== active.length)
+        return false;
+    return required.every(m => active.includes(m));
+}
+export function createGestureRegistry(defaultContainer) {
+    if (!defaultContainer) {
+        return { register: () => ({ enable() { }, disable() { }, destroy() { } }), destroy() { } };
+    }
+    const handlers = [];
+    const activePointers = new Map();
+    function onPointerDown(e) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!e.isPrimary)
+            return;
+        const mods = activeModifiers(e);
+        for (const h of handlers) {
+            if (!h.enabled || h.destroyed)
+                continue;
+            if (h.opts.type === 'pan' || h.opts.type === 'drag') {
+                const opts = h.opts;
+                const btn = (_a = opts.button) !== null && _a !== void 0 ? _a : 0;
+                if (e.button !== btn)
+                    continue;
+                if (!modifiersMatch((_b = opts.modifiers) !== null && _b !== void 0 ? _b : [], mods))
+                    continue;
+                const container = (_c = opts.container) !== null && _c !== void 0 ? _c : defaultContainer;
+                if (!container || !container.contains(e.target))
+                    continue;
+                const depth = ancestorCount(container);
+                const granted = claim(e.pointerId, { ownerId: h.id, axis: (_d = opts.axis) !== null && _d !== void 0 ? _d : 'xy', priority: 'normal', depth });
+                if (!granted)
+                    continue;
+                activePointers.set(e.pointerId, { handlerId: h.id, startX: e.clientX, startY: e.clientY, lastX: e.clientX, lastY: e.clientY });
+                const ev = { pointerId: e.pointerId, x: e.clientX, y: e.clientY, dx: 0, dy: 0 };
+                opts.onStart(ev);
+                document.addEventListener('pointermove', onPointerMove);
+                document.addEventListener('pointerup', onPointerUp);
+                document.addEventListener('pointercancel', onPointerCancel);
+                return;
+            }
+            if (h.opts.type === 'button') {
+                const opts = h.opts;
+                if (e.button !== opts.button)
+                    continue;
+                if (!modifiersMatch((_e = opts.modifiers) !== null && _e !== void 0 ? _e : [], mods))
+                    continue;
+                const container = (_f = opts.container) !== null && _f !== void 0 ? _f : defaultContainer;
+                if (!container || !container.contains(e.target))
+                    continue;
+                const on = (_g = opts.on) !== null && _g !== void 0 ? _g : 'down';
+                if (on === 'down' || on === 'both') {
+                    opts.onButton({ button: e.button, modifiers: mods, x: e.clientX, y: e.clientY });
+                }
+            }
+        }
+    }
+    function onPointerMove(e) {
+        const state = activePointers.get(e.pointerId);
+        if (!state)
+            return;
+        const h = handlers.find(h => h.id === state.handlerId);
+        if (!h || !h.enabled)
+            return;
+        const opts = h.opts;
+        const ev = {
+            pointerId: e.pointerId,
+            x: e.clientX, y: e.clientY,
+            dx: e.clientX - state.startX, dy: e.clientY - state.startY,
+        };
+        state.lastX = e.clientX;
+        state.lastY = e.clientY;
+        opts.onMove(ev);
+    }
+    function onPointerUp(e) {
+        var _a;
+        const state = activePointers.get(e.pointerId);
+        if (!state)
+            return;
+        activePointers.delete(e.pointerId);
+        revoke(e.pointerId, state.handlerId);
+        document.removeEventListener('pointermove', onPointerMove);
+        document.removeEventListener('pointerup', onPointerUp);
+        document.removeEventListener('pointercancel', onPointerCancel);
+        const h = handlers.find(h => h.id === state.handlerId);
+        if (!h)
+            return;
+        const opts = h.opts;
+        const dx = e.clientX - state.startX;
+        const dy = e.clientY - state.startY;
+        if (opts.type === 'drag') {
+            const threshold = (_a = opts.clickThreshold) !== null && _a !== void 0 ? _a : 6;
+            const dist = Math.sqrt(dx * dx + dy * dy);
+            opts.onEnd({ pointerId: e.pointerId, x: e.clientX, y: e.clientY, dx, dy, cancelled: false, wasClick: dist < threshold });
+        }
+        else {
+            opts.onEnd({ pointerId: e.pointerId, x: e.clientX, y: e.clientY, dx, dy, cancelled: false });
+        }
+    }
+    function onPointerCancel(e) {
+        const state = activePointers.get(e.pointerId);
+        if (!state)
+            return;
+        activePointers.delete(e.pointerId);
+        revoke(e.pointerId, state.handlerId);
+        document.removeEventListener('pointermove', onPointerMove);
+        document.removeEventListener('pointerup', onPointerUp);
+        document.removeEventListener('pointercancel', onPointerCancel);
+        const h = handlers.find(h => h.id === state.handlerId);
+        if (!h)
+            return;
+        const opts = h.opts;
+        const dx = state.lastX - state.startX;
+        const dy = state.lastY - state.startY;
+        if (opts.type === 'drag') {
+            opts.onEnd({ pointerId: e.pointerId, x: state.lastX, y: state.lastY, dx, dy, cancelled: true, wasClick: false });
+        }
+        else {
+            opts.onEnd({ pointerId: e.pointerId, x: state.lastX, y: state.lastY, dx, dy, cancelled: true });
+        }
+    }
+    function onWheel(e) {
+        var _a, _b;
+        const mods = activeModifiers(e);
+        for (const h of handlers) {
+            if (!h.enabled || h.destroyed)
+                continue;
+            if (h.opts.type !== 'scroll')
+                continue;
+            const opts = h.opts;
+            if (!modifiersMatch((_a = opts.modifiers) !== null && _a !== void 0 ? _a : [], mods))
+                continue;
+            const container = (_b = opts.container) !== null && _b !== void 0 ? _b : defaultContainer;
+            if (!container || !container.contains(e.target))
+                continue;
+            opts.onScroll({ deltaX: e.deltaX, deltaY: e.deltaY, deltaZ: e.deltaZ, modifiers: mods });
+            return;
+        }
+    }
+    defaultContainer.addEventListener('pointerdown', onPointerDown);
+    defaultContainer.addEventListener('wheel', onWheel);
+    return {
+        register(opts) {
+            const id = nextId();
+            const entry = { id, opts, enabled: false, destroyed: false };
+            handlers.push(entry);
+            return {
+                enable() { if (!entry.destroyed)
+                    entry.enabled = true; },
+                disable() { entry.enabled = false; },
+                destroy() {
+                    entry.enabled = false;
+                    entry.destroyed = true;
+                    const idx = handlers.indexOf(entry);
+                    if (idx >= 0)
+                        handlers.splice(idx, 1);
+                },
+            };
+        },
+        destroy() {
+            defaultContainer.removeEventListener('pointerdown', onPointerDown);
+            defaultContainer.removeEventListener('wheel', onWheel);
+            handlers.length = 0;
+        },
+    };
+}

package/dist/gestures/gestureRegistry.test.d.ts

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

package/dist/gestures/gestureRegistry.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { createGestureRegistry } from './gestureRegistry';
+import { __resetForTest } from './pointerClaim';
+beforeEach(() => {
+    __resetForTest();
+});
+afterEach(() => {
+    document.body.innerHTML = '';
+});
+function makeEl() {
+    const el = document.createElement('div');
+    document.body.appendChild(el);
+    return el;
+}
+function fire(target, type, init) {
+    target.dispatchEvent(new PointerEvent(type, Object.assign({ bubbles: true }, init)));
+}
+function fireWheel(el, init) {
+    el.dispatchEvent(new WheelEvent('wheel', Object.assign({ bubbles: true }, init)));
+}
+describe('GestureRegistry — pan', () => {
+    it('calls onStart/onMove/onEnd for a matching left-drag', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onStart = vi.fn();
+        const onMove = vi.fn();
+        const onEnd = vi.fn();
+        const handle = registry.register({
+            type: 'pan', button: 0, modifiers: [], axis: 'xy',
+            onStart, onMove, onEnd,
+        });
+        handle.enable();
+        fire(container, 'pointerdown', { pointerId: 1, button: 0, clientX: 10, clientY: 10, isPrimary: true });
+        expect(onStart).toHaveBeenCalledTimes(1);
+        fire(document, 'pointermove', { pointerId: 1, clientX: 20, clientY: 20, isPrimary: true });
+        expect(onMove).toHaveBeenCalledTimes(1);
+        fire(document, 'pointerup', { pointerId: 1, clientX: 20, clientY: 20, isPrimary: true });
+        expect(onEnd).toHaveBeenCalledTimes(1);
+        expect(onEnd.mock.calls[0][0]).toMatchObject({ cancelled: false });
+        registry.destroy();
+    });
+    it('does not fire when handle is disabled', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onStart = vi.fn();
+        registry.register({ type: 'pan', button: 0, modifiers: [], axis: 'xy', onStart, onMove: vi.fn(), onEnd: vi.fn() });
+        // handle stays disabled
+        fire(container, 'pointerdown', { pointerId: 1, button: 0, clientX: 10, clientY: 10, isPrimary: true });
+        expect(onStart).not.toHaveBeenCalled();
+        registry.destroy();
+    });
+    it('does not fire after destroy()', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onStart = vi.fn();
+        const handle = registry.register({ type: 'pan', button: 0, modifiers: [], axis: 'xy', onStart, onMove: vi.fn(), onEnd: vi.fn() });
+        handle.enable();
+        handle.destroy();
+        fire(container, 'pointerdown', { pointerId: 1, button: 0, clientX: 10, clientY: 10, isPrimary: true });
+        expect(onStart).not.toHaveBeenCalled();
+        registry.destroy();
+    });
+    it('delivers cancelled:true on pointercancel', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onEnd = vi.fn();
+        const handle = registry.register({ type: 'pan', button: 0, modifiers: [], axis: 'xy', onStart: vi.fn(), onMove: vi.fn(), onEnd });
+        handle.enable();
+        fire(container, 'pointerdown', { pointerId: 1, button: 0, clientX: 10, clientY: 10, isPrimary: true });
+        fire(document, 'pointercancel', { pointerId: 1, isPrimary: true });
+        expect(onEnd.mock.calls[0][0]).toMatchObject({ cancelled: true });
+        registry.destroy();
+    });
+});
+describe('GestureRegistry — scroll', () => {
+    it('calls onScroll for wheel events on container', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onScroll = vi.fn();
+        const handle = registry.register({ type: 'scroll', modifiers: [], onScroll });
+        handle.enable();
+        fireWheel(container, { deltaY: -100, bubbles: true });
+        expect(onScroll).toHaveBeenCalledTimes(1);
+        expect(onScroll.mock.calls[0][0]).toMatchObject({ deltaY: -100 });
+        registry.destroy();
+    });
+    it('does not fire when handle is disabled', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onScroll = vi.fn();
+        registry.register({ type: 'scroll', modifiers: [], onScroll });
+        // not enabled
+        fireWheel(container, { deltaY: -100, bubbles: true });
+        expect(onScroll).not.toHaveBeenCalled();
+        registry.destroy();
+    });
+});
+describe('GestureRegistry — button', () => {
+    it('calls onButton for matching button', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onButton = vi.fn();
+        const handle = registry.register({ type: 'button', button: 2, modifiers: [], on: 'down', onButton });
+        handle.enable();
+        fire(container, 'pointerdown', { pointerId: 1, button: 2, clientX: 5, clientY: 5, isPrimary: true });
+        expect(onButton).toHaveBeenCalledTimes(1);
+        registry.destroy();
+    });
+    it('does not fire for wrong button', () => {
+        const container = makeEl();
+        const registry = createGestureRegistry(container);
+        const onButton = vi.fn();
+        const handle = registry.register({ type: 'button', button: 2, modifiers: [], on: 'down', onButton });
+        handle.enable();
+        fire(container, 'pointerdown', { pointerId: 1, button: 0, clientX: 5, clientY: 5, isPrimary: true });
+        expect(onButton).not.toHaveBeenCalled();
+        registry.destroy();
+    });
+});

package/dist/gestures/index.d.ts

@@ -0,0 +1,6 @@
+export { claim, revoke, getOwner, isOwner } from './pointerClaim';
+export { createGestureRegistry } from './gestureRegistry';
+export type { GestureRegistry } from './gestureRegistry';
+export type { GestureHandle, GestureOptions, GestureType, Axis, ClaimPriority, ClaimEntry, PanEvent, ScrollEvent, ButtonEvent, } from './types';
+/** Internal utility — used by framework gesture sites. Not re-exported via api.ts. */
+export declare function ancestorCount(el: Element): number;

package/dist/gestures/index.js

@@ -0,0 +1,12 @@
+export { claim, revoke, getOwner, isOwner } from './pointerClaim';
+export { createGestureRegistry } from './gestureRegistry';
+/** Internal utility — used by framework gesture sites. Not re-exported via api.ts. */
+export function ancestorCount(el) {
+    let n = 0;
+    let cur = el;
+    while (cur) {
+        n++;
+        cur = cur.parentElement;
+    }
+    return n;
+}

package/dist/gestures/pointerClaim.d.ts

@@ -0,0 +1,7 @@
+import type { ClaimEntry } from './types';
+export declare function claim(pointerId: number, entry: ClaimEntry): boolean;
+export declare function revoke(pointerId: number, ownerId: string): void;
+export declare function getOwner(pointerId: number): ClaimEntry | null;
+export declare function isOwner(pointerId: number, ownerId: string): boolean;
+/** Test-only reset. */
+export declare function __resetForTest(): void;

package/dist/gestures/pointerClaim.js

@@ -0,0 +1,36 @@
+const claims = new Map();
+export function claim(pointerId, entry) {
+    const existing = claims.get(pointerId);
+    if (!existing) {
+        claims.set(pointerId, entry);
+        return true;
+    }
+    // Normal priority always beats edge priority.
+    if (existing.priority === 'edge' && entry.priority === 'normal') {
+        claims.set(pointerId, entry);
+        return true;
+    }
+    // Innermost-wins on same priority.
+    if (entry.priority === existing.priority && entry.depth > existing.depth) {
+        claims.set(pointerId, entry);
+        return true;
+    }
+    return false;
+}
+export function revoke(pointerId, ownerId) {
+    const existing = claims.get(pointerId);
+    if ((existing === null || existing === void 0 ? void 0 : existing.ownerId) === ownerId)
+        claims.delete(pointerId);
+}
+export function getOwner(pointerId) {
+    var _a;
+    return (_a = claims.get(pointerId)) !== null && _a !== void 0 ? _a : null;
+}
+export function isOwner(pointerId, ownerId) {
+    var _a;
+    return ((_a = claims.get(pointerId)) === null || _a === void 0 ? void 0 : _a.ownerId) === ownerId;
+}
+/** Test-only reset. */
+export function __resetForTest() {
+    claims.clear();
+}

package/dist/gestures/pointerClaim.test.d.ts

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

package/dist/gestures/pointerClaim.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { claim, revoke, getOwner, isOwner, __resetForTest } from './pointerClaim';
+beforeEach(() => __resetForTest());
+describe('claim', () => {
+    it('grants when no existing claim', () => {
+        const ok = claim(1, { ownerId: 'a', axis: 'x', priority: 'normal', depth: 5 });
+        expect(ok).toBe(true);
+    });
+    it('innermost-wins: deeper claim beats shallower', () => {
+        var _a;
+        claim(1, { ownerId: 'shallow', axis: 'x', priority: 'normal', depth: 3 });
+        const ok = claim(1, { ownerId: 'deep', axis: 'x', priority: 'normal', depth: 7 });
+        expect(ok).toBe(true);
+        expect((_a = getOwner(1)) === null || _a === void 0 ? void 0 : _a.ownerId).toBe('deep');
+    });
+    it('rejects claim from shallower node', () => {
+        var _a;
+        claim(1, { ownerId: 'deep', axis: 'x', priority: 'normal', depth: 7 });
+        const ok = claim(1, { ownerId: 'shallow', axis: 'x', priority: 'normal', depth: 3 });
+        expect(ok).toBe(false);
+        expect((_a = getOwner(1)) === null || _a === void 0 ? void 0 : _a.ownerId).toBe('deep');
+    });
+    it('normal priority beats edge priority regardless of depth', () => {
+        var _a;
+        claim(1, { ownerId: 'edge', axis: 'x', priority: 'edge', depth: 10 });
+        const ok = claim(1, { ownerId: 'app', axis: 'x', priority: 'normal', depth: 2 });
+        expect(ok).toBe(true);
+        expect((_a = getOwner(1)) === null || _a === void 0 ? void 0 : _a.ownerId).toBe('app');
+    });
+    it('edge priority cannot beat edge priority with same depth', () => {
+        claim(1, { ownerId: 'fw1', axis: 'x', priority: 'edge', depth: 5 });
+        const ok = claim(1, { ownerId: 'fw2', axis: 'x', priority: 'edge', depth: 5 });
+        expect(ok).toBe(false);
+    });
+});
+describe('revoke', () => {
+    it('clears the claim for that pointer', () => {
+        claim(1, { ownerId: 'a', axis: 'x', priority: 'normal', depth: 5 });
+        revoke(1, 'a');
+        expect(getOwner(1)).toBeNull();
+    });
+    it('is a no-op when ownerId does not match', () => {
+        var _a;
+        claim(1, { ownerId: 'a', axis: 'x', priority: 'normal', depth: 5 });
+        revoke(1, 'b');
+        expect((_a = getOwner(1)) === null || _a === void 0 ? void 0 : _a.ownerId).toBe('a');
+    });
+    it('is safe to call for unknown pointerId', () => {
+        expect(() => revoke(99, 'x')).not.toThrow();
+    });
+});
+describe('isOwner', () => {
+    it('returns true when ownerId matches', () => {
+        claim(1, { ownerId: 'a', axis: 'x', priority: 'normal', depth: 5 });
+        expect(isOwner(1, 'a')).toBe(true);
+    });
+    it('returns false when ownerId does not match', () => {
+        claim(1, { ownerId: 'a', axis: 'x', priority: 'normal', depth: 5 });
+        expect(isOwner(1, 'b')).toBe(false);
+    });
+    it('returns false for unclaimed pointer', () => {
+        expect(isOwner(42, 'a')).toBe(false);
+    });
+});

package/dist/gestures/types.d.ts

@@ -0,0 +1,83 @@
+export type Axis = 'x' | 'y' | 'xy' | 'any';
+export type ClaimPriority = 'edge' | 'normal';
+export interface ClaimEntry {
+    ownerId: string;
+    axis: Axis;
+    priority: ClaimPriority;
+    /** DOM ancestor count at claim time — higher = deeper = wins on ties. */
+    depth: number;
+}
+export type GestureType = 'pan' | 'drag' | 'button' | 'scroll';
+export type ButtonEventOn = 'down' | 'up' | 'both';
+export interface PanEvent {
+    pointerId: number;
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    cancelled?: boolean;
+}
+export interface ScrollEvent {
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    modifiers: string[];
+}
+export interface ButtonEvent {
+    button: number;
+    modifiers: string[];
+    x: number;
+    y: number;
+}
+export interface PanOptions {
+    type: 'pan';
+    /** Mouse button number. 0=left, 1=middle, 2=right. Default: 0. */
+    button?: number;
+    /** Required modifier keys. E.g. ['Control']. Empty array means no modifiers. */
+    modifiers?: string[];
+    /** Axis to claim. Default: 'xy'. */
+    axis?: Axis;
+    /** Claim region. Defaults to shard root element if omitted. */
+    container?: HTMLElement;
+    onStart: (e: PanEvent) => void;
+    onMove: (e: PanEvent) => void;
+    onEnd: (e: PanEvent & {
+        cancelled?: boolean;
+    }) => void;
+}
+export interface DragOptions {
+    type: 'drag';
+    button?: number;
+    modifiers?: string[];
+    /** Movement px threshold below which release is treated as a click. Default: 6. */
+    clickThreshold?: number;
+    axis?: Axis;
+    container?: HTMLElement;
+    onStart: (e: PanEvent) => void;
+    onMove: (e: PanEvent) => void;
+    onEnd: (e: PanEvent & {
+        cancelled?: boolean;
+        wasClick: boolean;
+    }) => void;
+}
+export interface ButtonOptions {
+    type: 'button';
+    button: number;
+    modifiers?: string[];
+    on?: ButtonEventOn;
+    container?: HTMLElement;
+    onButton: (e: ButtonEvent) => void;
+}
+export interface ScrollOptions {
+    type: 'scroll';
+    modifiers?: string[];
+    axis?: 'x' | 'y' | 'xy';
+    container?: HTMLElement;
+    onScroll: (e: ScrollEvent) => void;
+}
+export type GestureOptions = PanOptions | DragOptions | ButtonOptions | ScrollOptions;
+export interface GestureHandle {
+    enable(): void;
+    disable(): void;
+    destroy(): void;
+}

package/dist/gestures/types.js

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

package/dist/host-entry.d.ts

@@ -4,6 +4,7 @@ export { __setActiveScope, __setTenantId, __setDocumentBackend } from './host';
 export type { Backend } from './state/types';
 export type { DocumentBackend } from './documents/types';
 export { HttpDocumentBackend } from './documents/http-backend';
+export { IndexedDBDocumentBackend, MemoryDocumentBackend } from './documents/backends';
 export { __setEnvServerUrl } from './env/index';
 export { installPackage, uninstallPackage, listInstalledPackages, loadInstalledPackages, } from './registry/index';
 export type { InstalledPackage, InstallResult, PackageMeta } from './registry/types';

package/dist/host-entry.js

@@ -8,6 +8,7 @@
 export { registerShard, registerApp, bootstrap, __setBackend, setLocalOwner } from './host';
 export { __setActiveScope, __setTenantId, __setDocumentBackend } from './host';
 export { HttpDocumentBackend } from './documents/http-backend';
+export { IndexedDBDocumentBackend, MemoryDocumentBackend } from './documents/backends';
 export { __setEnvServerUrl } from './env/index';
 // Install API (host-only).
 export { installPackage, uninstallPackage, listInstalledPackages, loadInstalledPackages, } from './registry/index';