@jgengine/core 0.7.0 → 0.8.0

package/dist/game/social.js

@@ -72,12 +72,25 @@ export function createSocial(deps) {
                     friendRequests.delete(requestId);
             }
         },
+        decline(userId, requestId) {
+            const request = friendRequests.get(requestId);
+            if (request !== undefined && request.to === userId)
+                friendRequests.delete(requestId);
+        },
         list(userId) {
             return Array.from(friendships.get(userId) ?? [], (friendUserId) => ({
                 userId: friendUserId,
                 online: deps.presence?.(friendUserId).online ?? false,
             }));
         },
+        requestsFor(userId) {
+            const entries = [];
+            for (const [requestId, request] of friendRequests) {
+                if (request.to === userId)
+                    entries.push({ requestId, fromUserId: request.from });
+            }
+            return entries;
+        },
         snapshot(userId) {
             return {
                 friends: Array.from(friendships.get(userId) ?? []),
@@ -212,9 +225,117 @@ export function createSocial(deps) {
                 role: member === current.leader ? "leader" : "member",
             }));
         },
+        decline(userId, inviteId) {
+            const invite = partyInvites.get(inviteId);
+            if (invite !== undefined && invite.to === userId)
+                partyInvites.delete(inviteId);
+        },
         membersOf(userId) {
             return partyOf(userId)?.members.slice() ?? [];
         },
+        invitesFor(userId) {
+            const ttlMs = partyConfig?.inviteTtlMs ?? DEFAULT_INVITE_TTL_MS;
+            const cutoff = now() - ttlMs;
+            const entries = [];
+            for (const [inviteId, invite] of partyInvites) {
+                if (invite.createdAt < cutoff) {
+                    partyInvites.delete(inviteId);
+                    continue;
+                }
+                if (invite.to === userId) {
+                    entries.push({ inviteId, fromUserId: invite.from, createdAt: invite.createdAt });
+                }
+            }
+            return entries;
+        },
+    };
+    const worldInviteTtlMs = deps.worldInviteTtlMs ?? DEFAULT_INVITE_TTL_MS;
+    const worldInviteEntries = new Map();
+    let worldInviteCounter = 0;
+    function pruneWorldInvites() {
+        const cutoff = now() - worldInviteTtlMs;
+        for (const [id, entry] of worldInviteEntries) {
+            if (entry.createdAt < cutoff)
+                worldInviteEntries.delete(id);
+        }
+    }
+    function canWorldInvite(fromUserId, toUserId) {
+        if (fromUserId === toUserId)
+            return { reason: "cannot invite yourself" };
+        if (blocked.get(toUserId)?.has(fromUserId) || blocked.get(fromUserId)?.has(toUserId)) {
+            return { reason: "blocked" };
+        }
+        pruneWorldInvites();
+        for (const entry of worldInviteEntries.values()) {
+            if (entry.fromUserId === fromUserId && entry.toUserId === toUserId) {
+                return { reason: "invite already pending" };
+            }
+        }
+        return null;
+    }
+    const worldInvites = {
+        canInvite: canWorldInvite,
+        invite(fromUserId, toUserId, target) {
+            const denied = canWorldInvite(fromUserId, toUserId);
+            if (denied !== null)
+                return denied;
+            worldInviteCounter += 1;
+            const inviteId = `winv_${worldInviteCounter}`;
+            const entry = {
+                id: inviteId,
+                fromUserId,
+                toUserId,
+                serverId: target.serverId,
+                createdAt: now(),
+            };
+            if (target.joinCode !== undefined)
+                entry.joinCode = target.joinCode;
+            worldInviteEntries.set(inviteId, entry);
+            const invited = {
+                inviteId,
+                fromUserId,
+                toUserId,
+                serverId: target.serverId,
+            };
+            if (target.joinCode !== undefined)
+                invited.joinCode = target.joinCode;
+            events.emit("social.world.invited", invited);
+            return { inviteId };
+        },
+        accept(userId, inviteId) {
+            const entry = worldInviteEntries.get(inviteId);
+            if (entry === undefined)
+                return { reason: `unknown invite "${inviteId}"` };
+            if (entry.toUserId !== userId)
+                return { reason: "invite is not addressed to this user" };
+            if (now() - entry.createdAt > worldInviteTtlMs) {
+                worldInviteEntries.delete(inviteId);
+                return { reason: "invite expired" };
+            }
+            worldInviteEntries.delete(inviteId);
+            const target = { serverId: entry.serverId };
+            if (entry.joinCode !== undefined)
+                target.joinCode = entry.joinCode;
+            const accepted = {
+                inviteId,
+                userId,
+                fromUserId: entry.fromUserId,
+                serverId: entry.serverId,
+            };
+            if (entry.joinCode !== undefined)
+                accepted.joinCode = entry.joinCode;
+            events.emit("social.world.accepted", accepted);
+            return { target };
+        },
+        decline(userId, inviteId) {
+            const entry = worldInviteEntries.get(inviteId);
+            if (entry !== undefined && entry.toUserId === userId)
+                worldInviteEntries.delete(inviteId);
+        },
+        listFor(userId) {
+            pruneWorldInvites();
+            return Array.from(worldInviteEntries.values()).filter((entry) => entry.toUserId === userId);
+        },
     };
     const emotes = {
         play(fromUserId, emoteId, radius) {
@@ -239,5 +360,6 @@ export function createSocial(deps) {
             },
         },
         emotes,
+        worldInvites,
     };
 }

package/dist/game/spawnPoints.d.ts

@@ -0,0 +1,19 @@
+import type { EntityPose } from "../scene/entityStore.js";
+export interface SpawnPointPose {
+    x: number;
+    y: number;
+    z: number;
+    rotationY?: number;
+}
+export interface RespawnTarget {
+    setPose(id: string, pose: EntityPose): boolean;
+}
+export interface SpawnPoints {
+    record(id: string, pose: SpawnPointPose): void;
+    get(id: string): SpawnPointPose | undefined;
+    list(): readonly (SpawnPointPose & {
+        id: string;
+    })[];
+    respawn(entities: RespawnTarget, entityId: string, spawnId: string): boolean;
+}
+export declare function createSpawnPoints(): SpawnPoints;

package/dist/game/spawnPoints.js

@@ -0,0 +1,23 @@
+export function createSpawnPoints() {
+    const points = new Map();
+    return {
+        record(id, pose) {
+            points.set(id, { ...pose });
+        },
+        get(id) {
+            return points.get(id);
+        },
+        list() {
+            return Array.from(points, ([id, pose]) => ({ id, ...pose }));
+        },
+        respawn(entities, entityId, spawnId) {
+            const pose = points.get(spawnId);
+            if (pose === undefined)
+                return false;
+            return entities.setPose(entityId, {
+                position: { x: pose.x, y: pose.y, z: pose.z },
+                ...(pose.rotationY === undefined ? {} : { rotationY: pose.rotationY }),
+            });
+        },
+    };
+}

package/dist/game/worldItem.d.ts

@@ -44,7 +44,10 @@ export interface WorldItemStore {
     get(instanceId: string): WorldItemRecord | null;
     list(): readonly WorldItemRecord[];
     nearestInRadius(from: EntityPosition, radius: number, filter?: (record: WorldItemRecord) => boolean): string | null;
+    /** Detaches the record for a pickup: caller is expected to grant its contents (e.g. `loot.grantToPlayer`) itself. */
     take(instanceId: string): WorldItemRecord | null;
+    /** Consumes/destroys the record with no grant implied (decay, an explosion, a cleanup sweep) — same despawn path as `take`, leaves no orphaned record. */
+    remove(instanceId: string): WorldItemRecord | null;
 }
 /** Pure pickup-radius + nearest-item selection, usable without a live store (click-to-grab, proximity prompts). */
 export declare function selectNearestWorldItem(candidates: readonly {

package/dist/game/worldItem.js

@@ -33,6 +33,14 @@ export function selectNearestWorldItem(candidates, from, radius) {
 export function createWorldItemStore(deps) {
     const records = new Map();
     const now = deps.now ?? Date.now;
+    function removeRecord(instanceId) {
+        const record = records.get(instanceId);
+        if (record === undefined)
+            return null;
+        records.delete(instanceId);
+        deps.despawnEntity(instanceId);
+        return record;
+    }
     return {
         spawn(input) {
             const instanceId = deps.spawnEntity(input.position);
@@ -69,12 +77,10 @@ export function createWorldItemStore(deps) {
             return selectNearestWorldItem(candidates, from, radius);
         },
         take(instanceId) {
-            const record = records.get(instanceId);
-            if (record === undefined)
-                return null;
-            records.delete(instanceId);
-            deps.despawnEntity(instanceId);
-            return record;
+            return removeRecord(instanceId);
+        },
+        remove(instanceId) {
+            return removeRecord(instanceId);
         },
     };
 }

package/dist/input/actionBindings.d.ts

@@ -27,8 +27,18 @@ export type ActionStateBindingMap<TAction extends string, TCode extends string =
 export type ActionCodes<TCode extends string = string> = readonly TCode[] | {
     hold?: readonly TCode[];
     toggle?: readonly TCode[];
+    repeatMs?: number;
 };
 export type ActionCodesMap<TAction extends string = string, TCode extends string = string> = Record<TAction, ActionCodes<TCode>>;
+export declare function actionRepeatMs(codes: ActionCodes | undefined): number | undefined;
+export interface ShouldDispatchActionInput {
+    pressed: boolean;
+    down: boolean;
+    repeatMs: number | undefined;
+    lastFiredAt: number | null;
+    now: number;
+}
+export declare function shouldDispatchAction({ pressed, down, repeatMs, lastFiredAt, now }: ShouldDispatchActionInput): boolean;
 export declare function toActionStateBindingMap<TAction extends string, TCode extends string>(map: ActionCodesMap<TAction, TCode>): ActionStateBindingMap<TAction, TCode>;
 export declare function hotbarSlotBindings(count: number, options?: {
     action?: (slot: number) => string;

package/dist/input/actionBindings.js

@@ -27,6 +27,20 @@ export function normalizeKeyCode(code) {
         return "Control";
     return code;
 }
+export function actionRepeatMs(codes) {
+    if (codes === undefined || Array.isArray(codes))
+        return undefined;
+    return codes.repeatMs;
+}
+export function shouldDispatchAction({ pressed, down, repeatMs, lastFiredAt, now }) {
+    if (pressed)
+        return true;
+    if (repeatMs === undefined || repeatMs <= 0)
+        return false;
+    if (!down || lastFiredAt === null)
+        return false;
+    return now - lastFiredAt >= repeatMs;
+}
 function toBindings(codes) {
     return codes.map((code) => ({ primary: code, secondary: null }));
 }

package/dist/input/gestureSurface.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Single-finger play-surface gesture recognizer for touch controls: taps,
+ * directional flick swipes, and continuous step drags all resolve to action
+ * names from a TouchGestureBindings declaration. Drag steps stream out of
+ * move() as the finger travels; taps and swipes resolve on end(). Timestamps
+ * are injected so the state machine stays pure; the capture layer owns touch
+ * identifiers and pointer capture.
+ */
+import type { TouchGestureBindings } from "./touchScheme.js";
+export interface GestureSurfaceTuning {
+    /** A finger that moves less than this (px) and lifts quickly is a tap. */
+    tapMoveThresholdPx: number;
+    tapMaxMs: number;
+    /** Minimum travel (px) for a lift to register as a swipe. */
+    swipeMinPx: number;
+    /** Minimum lift velocity (px/ms) for a swipe; slower travel is a drag that ends quietly. */
+    swipeMinVelocity: number;
+    /** Default travel (px) per repeated drag action when the binding sets none. */
+    dragStepPx: number;
+}
+export declare const DEFAULT_GESTURE_TUNING: GestureSurfaceTuning;
+export interface GestureSurfaceTracker {
+    begin(x: number, y: number, nowMs: number): void;
+    /** Drag-step actions fired by this movement, in travel order. */
+    move(x: number, y: number): readonly string[];
+    /** Tap or swipe action resolved by lifting the finger, if any. */
+    end(x: number, y: number, nowMs: number): readonly string[];
+    cancel(): void;
+    isActive(): boolean;
+}
+export declare function createGestureSurfaceTracker(bindings: TouchGestureBindings, tuning?: GestureSurfaceTuning): GestureSurfaceTracker;

package/dist/input/gestureSurface.js

@@ -0,0 +1,120 @@
+/**
+ * Single-finger play-surface gesture recognizer for touch controls: taps,
+ * directional flick swipes, and continuous step drags all resolve to action
+ * names from a TouchGestureBindings declaration. Drag steps stream out of
+ * move() as the finger travels; taps and swipes resolve on end(). Timestamps
+ * are injected so the state machine stays pure; the capture layer owns touch
+ * identifiers and pointer capture.
+ */
+export const DEFAULT_GESTURE_TUNING = {
+    tapMoveThresholdPx: 12,
+    tapMaxMs: 280,
+    swipeMinPx: 48,
+    swipeMinVelocity: 0.45,
+    dragStepPx: 36,
+};
+export function createGestureSurfaceTracker(bindings, tuning = DEFAULT_GESTURE_TUNING) {
+    const drag = bindings.drag;
+    const dragStepPx = drag?.stepPx ?? tuning.dragStepPx;
+    const dragBound = {
+        horizontal: drag?.left !== undefined || drag?.right !== undefined,
+        vertical: drag?.up !== undefined || drag?.down !== undefined,
+    };
+    let active = false;
+    let startX = 0;
+    let startY = 0;
+    let lastX = 0;
+    let lastY = 0;
+    let startTime = 0;
+    let moved = false;
+    let axis = null;
+    let dragAccum = 0;
+    let dragStepsFired = 0;
+    const commitAxis = (totalDx, totalDy) => {
+        if (axis !== null)
+            return;
+        axis = Math.abs(totalDx) >= Math.abs(totalDy) ? "horizontal" : "vertical";
+    };
+    const swipeFor = (totalDx, totalDy) => {
+        if (axis === "horizontal") {
+            return totalDx >= 0 ? bindings.swipeRight : bindings.swipeLeft;
+        }
+        return totalDy >= 0 ? bindings.swipeDown : bindings.swipeUp;
+    };
+    const dragActionFor = (direction) => {
+        if (axis === "horizontal")
+            return direction >= 0 ? drag?.right : drag?.left;
+        return direction >= 0 ? drag?.down : drag?.up;
+    };
+    return {
+        begin(x, y, nowMs) {
+            active = true;
+            startX = lastX = x;
+            startY = lastY = y;
+            startTime = nowMs;
+            moved = false;
+            axis = null;
+            dragAccum = 0;
+            dragStepsFired = 0;
+        },
+        move(x, y) {
+            if (!active)
+                return [];
+            const totalDx = x - startX;
+            const totalDy = y - startY;
+            if (!moved && Math.hypot(totalDx, totalDy) > tuning.tapMoveThresholdPx) {
+                moved = true;
+                commitAxis(totalDx, totalDy);
+            }
+            const fired = [];
+            if (moved && axis !== null && dragBound[axis]) {
+                const delta = axis === "horizontal" ? x - lastX : y - lastY;
+                if (delta !== 0 && dragAccum !== 0 && Math.sign(delta) !== Math.sign(dragAccum))
+                    dragAccum = 0;
+                dragAccum += delta;
+                while (Math.abs(dragAccum) >= dragStepPx) {
+                    const direction = Math.sign(dragAccum);
+                    const action = dragActionFor(direction);
+                    dragAccum -= direction * dragStepPx;
+                    if (action !== undefined) {
+                        fired.push(action);
+                        dragStepsFired += 1;
+                    }
+                }
+            }
+            lastX = x;
+            lastY = y;
+            return fired;
+        },
+        end(x, y, nowMs) {
+            if (!active)
+                return [];
+            active = false;
+            const totalDx = x - startX;
+            const totalDy = y - startY;
+            const elapsed = nowMs - startTime;
+            if (!moved) {
+                if (elapsed <= tuning.tapMaxMs && bindings.tap !== undefined)
+                    return [bindings.tap];
+                return [];
+            }
+            const travel = Math.hypot(totalDx, totalDy);
+            const velocity = elapsed <= 0 ? Infinity : travel / elapsed;
+            if (travel < tuning.swipeMinPx || velocity < tuning.swipeMinVelocity)
+                return [];
+            const direction = axis === "horizontal" ? Math.sign(totalDx) : Math.sign(totalDy);
+            if (axis !== null && dragBound[axis] && dragActionFor(direction) !== undefined)
+                return [];
+            const swipe = swipeFor(totalDx, totalDy);
+            if (swipe === undefined || dragStepsFired > 0)
+                return [];
+            return [swipe];
+        },
+        cancel() {
+            active = false;
+        },
+        isActive() {
+            return active;
+        },
+    };
+}

package/dist/input/pointer.d.ts

@@ -14,6 +14,19 @@ export interface PointerHit {
     entity: string | null;
     /** Topmost scene-object instance id under the cursor, or null. */
     object: string | null;
+    /** Texture-space UV at the hit, when the intersected mesh carries UVs; absent for the ground-plane fallback. */
+    uv?: {
+        u: number;
+        v: number;
+    };
+    /** Sampled `#rrggbb` color + PBR params from the hit mesh's `MeshStandardMaterial` (#151.2); `null`/unset when the hit surface has no standard material (e.g. the ground plane). */
+    material?: {
+        color: string;
+        metalness?: number;
+        roughness?: number;
+    } | null;
+    /** Index of the hit instance when the intersected mesh is a `THREE.InstancedMesh`; absent otherwise. */
+    instanceId?: number;
 }
 export type PointerButton = "primary" | "secondary" | "middle";
 /** Build an `origin → point` aim for `item.use` / projectiles, firing toward the cursor. */
@@ -22,3 +35,35 @@ export declare function aimToPoint(origin: PointerVec3, point: PointerVec3): Aim
 export declare function moveTargetFromHit(hit: PointerHit): PointerVec3;
 /** Project a pointer hit onto the XZ plane for navmesh routing (`findPath` takes `[x, z]`). */
 export declare function groundOf(hit: PointerHit): readonly [number, number];
+/** Snapshot of an in-progress or just-released drag: origin/current cursor points plus the clamped pull vector. */
+export interface DragState {
+    origin: PointerVec3;
+    current: PointerVec3;
+    /** `current - origin`, clamped to `maxPull` in length. */
+    pull: PointerVec3;
+    /** Length of `pull`, at most `maxPull`. */
+    magnitude: number;
+    /** `magnitude / maxPull`, in `[0, 1]`. `0` when `maxPull` is unset. */
+    fraction: number;
+}
+export type DragResult = DragState;
+export interface DragCaptureConfig {
+    /** Clamp on pull-vector length. Unset (default) means unclamped. */
+    maxPull?: number;
+    /** Max distance from `origin` a `begin()` point may be to start a drag. Unset (default) means unrestricted. */
+    grabRadius?: number;
+}
+/** Renderer-agnostic drag-capture / pull-vector state machine for slingshot-style aiming, drawback abilities, and similar gestures. */
+export interface DragCapture {
+    /** Start a drag at `origin` if `at` is within `grabRadius` of it. Returns whether the drag started. */
+    begin(origin: PointerVec3, at: PointerVec3): boolean;
+    /** Move the drag's current point. No-op when no drag is active. */
+    update(at: PointerVec3): void;
+    /** End the drag, returning its final state, or `null` if no drag was active. */
+    release(): DragResult | null;
+    /** Abort the drag without producing a result. */
+    cancel(): void;
+    /** The current drag state, or `null` when idle. */
+    state(): DragState | null;
+}
+export declare function createDragCapture(config?: DragCaptureConfig): DragCapture;

package/dist/input/pointer.js

@@ -15,3 +15,51 @@ export function moveTargetFromHit(hit) {
 export function groundOf(hit) {
     return [hit.point[0], hit.point[2]];
 }
+function subtractVec3(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function lengthVec3(v) {
+    return Math.hypot(v[0], v[1], v[2]);
+}
+export function createDragCapture(config = {}) {
+    const maxPull = config.maxPull ?? Number.POSITIVE_INFINITY;
+    const grabRadius = config.grabRadius ?? Number.POSITIVE_INFINITY;
+    let origin = null;
+    let current = null;
+    function snapshot() {
+        if (origin === null || current === null)
+            return null;
+        const offset = subtractVec3(current, origin);
+        const rawLength = lengthVec3(offset);
+        const scale = rawLength > maxPull && rawLength > 0 ? maxPull / rawLength : 1;
+        const pull = [offset[0] * scale, offset[1] * scale, offset[2] * scale];
+        const magnitude = Math.min(rawLength, maxPull);
+        const fraction = Number.isFinite(maxPull) && maxPull > 0 ? magnitude / maxPull : 0;
+        return { origin, current, pull, magnitude, fraction };
+    }
+    return {
+        begin(dragOrigin, at) {
+            if (lengthVec3(subtractVec3(at, dragOrigin)) > grabRadius)
+                return false;
+            origin = dragOrigin;
+            current = at;
+            return true;
+        },
+        update(at) {
+            if (origin === null)
+                return;
+            current = at;
+        },
+        release() {
+            const result = snapshot();
+            origin = null;
+            current = null;
+            return result;
+        },
+        cancel() {
+            origin = null;
+            current = null;
+        },
+        state: snapshot,
+    };
+}

package/dist/input/touchScheme.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Touch control scheme derived from a game's existing action bindings: the
+ * capture layer renders a virtual joystick, on-screen buttons, and a gesture
+ * surface, and feeds synthetic `touch:<action>` codes into the same
+ * ActionStateTracker the keyboard uses, so games gain touch play without any
+ * per-game input code. Games refine the derived defaults through
+ * TouchControlsConfig (gesture bindings, button curation) or opt out entirely
+ * with `touch: false`.
+ */
+import { type ActionCodesMap } from "./actionBindings.js";
+export declare const TOUCH_CODE_PREFIX = "touch:";
+export declare function touchCode(action: string): string;
+/** Every action gains a synthetic touch code alongside its physical codes. */
+export declare function withTouchCodes(map: ActionCodesMap | undefined): ActionCodesMap;
+export interface TouchDragBinding {
+    /** Action fired once per `stepPx` of travel toward that side. */
+    left?: string;
+    right?: string;
+    up?: string;
+    down?: string;
+    stepPx?: number;
+}
+export interface TouchGestureBindings {
+    /** Action fired by a quick still tap on the play surface. */
+    tap?: string;
+    /** Actions fired by a fast flick past the swipe threshold. */
+    swipeUp?: string;
+    swipeDown?: string;
+    swipeLeft?: string;
+    swipeRight?: string;
+    /** Continuous drag: repeats the directional action every `stepPx` of travel. Wins over swipes on its axis, except a flick can still fire the swipe binding for a direction the drag leaves unbound. */
+    drag?: TouchDragBinding;
+}
+export interface TouchButtonSpec {
+    action: string;
+    label?: string;
+    /** Glyph name from the capture layer's icon catalog (`@jgengine/react/gameIcons` `GameIconName`); unset derives one from the action name, `false` forces the text label. */
+    icon?: string | false;
+}
+export interface TouchControlsConfig {
+    /** `false` removes the virtual joystick even when movement actions are bound. */
+    movement?: false;
+    /** Curated on-screen buttons (order preserved); omit to derive one button per remaining action. */
+    buttons?: readonly (string | TouchButtonSpec)[];
+    /** Play-surface gestures; actions consumed here stop appearing as derived buttons. */
+    gestures?: TouchGestureBindings;
+    /** Drag-to-look on the play surface; defaults to true for first-person games. */
+    look?: boolean;
+    /** Radians of look rotation per pixel of touch travel. Default 0.005. */
+    lookSensitivity?: number;
+    /** Actions to leave off the derived button cluster. */
+    hidden?: readonly string[];
+}
+export interface TouchJoystick {
+    up: string | null;
+    down: string | null;
+    left: string | null;
+    right: string | null;
+}
+export interface TouchButton {
+    action: string;
+    label: string;
+    /** Glyph hint for the capture layer: a name to render, `false` to force text, null to derive from the action name. */
+    icon: string | false | null;
+}
+export interface TouchScheme {
+    joystick: TouchJoystick | null;
+    buttons: readonly TouchButton[];
+    gestures: TouchGestureBindings | null;
+    look: boolean;
+    lookSensitivity: number;
+}
+export declare function touchActionLabel(action: string): string;
+export interface DeriveTouchSchemeOptions {
+    reserved: ReadonlySet<string>;
+    firstPerson: boolean;
+    config?: TouchControlsConfig | false;
+}
+/**
+ * Null means "render no touch controls" — either the game opted out or there
+ * is nothing to synthesize.
+ */
+export declare function deriveTouchScheme(input: ActionCodesMap | undefined, { reserved, firstPerson, config }: DeriveTouchSchemeOptions): TouchScheme | null;