@tak-ps/cloudtak 13.2.0 → 13.4.0

package/dist/types/src/components/CloudTAK/util/InlineExpiration.vue.d.ts

@@ -38,8 +38,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     onCancel?: (() => any) | undefined;
     onDisplayClick?: (() => any) | undefined;
 }>, {
-    label: string;
     value: string | null;
+    label: string;
     gap: string;
     background: string;
     shadow: boolean;

package/dist/types/src/components/CloudTAK/util/InlineGroupSelect.vue.d.ts

@@ -36,9 +36,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     onSave?: ((value: string[]) => any) | undefined;
     onCancel?: (() => any) | undefined;
 }>, {
-    label: string;
     direction: string;
     active: boolean;
+    label: string;
     gap: string;
     background: string;
     shadow: boolean;

package/dist/types/src/components/CloudTAK/util/Keywords.vue.d.ts

@@ -4,8 +4,8 @@ type __VLS_Props = {
     tone?: 'muted' | 'accent';
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    placeholder: string;
     keywords: string[];
+    placeholder: string;
     tone: "muted" | "accent";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/types/src/components/CloudTAK/util/TagEntry.vue.d.ts

@@ -23,13 +23,13 @@ declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, i
     "on-limit": () => any;
     "on-error": (error: Error) => any;
     "on-focus": (event: FocusEvent) => any;
-    "on-blur": (event: FocusEvent | KeyboardEvent) => any;
+    "on-blur": (event: KeyboardEvent | FocusEvent) => any;
 }, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
     "onOn-limit"?: (() => any) | undefined;
     "onOn-error"?: ((error: Error) => any) | undefined;
     "onOn-focus"?: ((event: FocusEvent) => any) | undefined;
-    "onOn-blur"?: ((event: FocusEvent | KeyboardEvent) => any) | undefined;
+    "onOn-blur"?: ((event: KeyboardEvent | FocusEvent) => any) | undefined;
 }>, {
     modelValue: string[];
     disabled: boolean;

package/dist/types/src/components/CloudTAK/util/featureCut.d.ts

@@ -1,10 +1,10 @@
 import type { Feature } from 'geojson';
 import type { MapGeoJSONFeature } from 'maplibre-gl';
 import type { useMapStore } from '../../../stores/map.ts';
-import type Overlay from '../../../base/overlay.ts';
+import type Overlay from '../../../base/overlay-class.ts';
 type FeatureLike = Feature | MapGeoJSONFeature;
 type MapStore = ReturnType<typeof useMapStore>;
-export declare function getFeatureOverlay(mapStore: MapStore, feature?: FeatureLike): Overlay | null;
-export declare function canCutOverlayFeature(mapStore: MapStore, feature?: FeatureLike): boolean;
+export declare function getFeatureOverlay(feature?: FeatureLike): Overlay | null;
+export declare function canCutOverlayFeature(feature?: FeatureLike): boolean;
 export declare function cutOverlayFeature(mapStore: MapStore, feature?: FeatureLike): Promise<void>;
 export {};

package/dist/types/src/components/util/HandleForm.vue.d.ts

@@ -17,13 +17,13 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
 }>, {
-    label: string;
     description: string;
+    schema: SchemaNode;
+    label: string;
     modelValue: string | number;
     disabled: boolean;
     rows: number | string;
     placeholder: string;
-    schema: SchemaNode;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/util/Upload.vue.d.ts

@@ -21,24 +21,24 @@ declare const __VLS_export: import("vue").DefineComponent<Props, {
     refresh: typeof refresh;
     upload: typeof upload;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    done: (response: unknown) => any;
     error: (response: Error) => any;
+    done: (response: unknown) => any;
     cancel: () => any;
     staged: (response: {
         name: string;
     }) => any;
 }, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
-    onDone?: ((response: unknown) => any) | undefined;
     onError?: ((response: Error) => any) | undefined;
+    onDone?: ((response: unknown) => any) | undefined;
     onCancel?: (() => any) | undefined;
     onStaged?: ((response: {
         name: string;
     }) => any) | undefined;
 }>, {
-    label: string;
     method: string;
-    format: "formdata" | "raw";
     headers: Record<string, string>;
+    label: string;
+    format: "formdata" | "raw";
     cancel: boolean;
     autoupload: boolean;
     mimetype: string;

package/dist/types/src/database.d.ts

@@ -1,5 +1,5 @@
 import Dexie, { type EntityTable } from 'dexie';
-import type { Feature, GroupChannel, Mission, MissionRole, MissionChange, MissionLog, Contact, Server } from './types.ts';
+import type { Feature, GroupChannel, Mission, MissionRole, MissionChange, MissionLog, Contact, Server, ProfileOverlayList } from './types.ts';
 export interface DBIcon {
     /** Maplibre image id, e.g. "<iconsetUid>:<icon-path-without-extension>" */
     name: string;
@@ -56,6 +56,7 @@ export interface DBIconset {
     default_unknown: string | null;
     skip_resize: boolean;
 }
+export type DBOverlay = ProfileOverlayList["items"][number];
 export interface DBFilter {
     id: string;
     external: string;
@@ -82,6 +83,10 @@ export interface DBNotification {
     read: boolean;
     created: string;
 }
+export interface DBKV {
+    key: string;
+    value: string;
+}
 export interface DBVideo {
     id: string;
     created: string;
@@ -183,6 +188,7 @@ export interface DBSprite {
 export type DatabaseType = Dexie & {
     icon: EntityTable<DBIcon, 'name'>;
     iconset: EntityTable<DBIconset, 'uid'>;
+    overlay: EntityTable<DBOverlay, 'id'>;
     sprite: EntityTable<DBSprite, 'id'>;
     group: EntityTable<GroupChannel, 'name'>;
     video: EntityTable<DBVideo, 'id'>;
@@ -201,6 +207,7 @@ export type DatabaseType = Dexie & {
     subscription_chat: EntityTable<DBSubscriptionChat, 'id'>;
     mission_template: EntityTable<DBMissionTemplate, 'id'>;
     mission_template_log: EntityTable<DBMissionTemplateLog, 'id'>;
+    kv: EntityTable<DBKV, 'key'>;
     profile: EntityTable<DBProfileConfig, 'key'>;
     config: EntityTable<DBConfig, 'key'>;
     cache: EntityTable<DBCache, 'key'>;

package/dist/types/src/router.d.ts

@@ -1,3 +1,3 @@
 import * as VueRouter from 'vue-router';
-declare const router: VueRouter.Router;
+declare const router: VueRouter._RouterClassic;
 export default router;

package/dist/types/src/std.d.ts

@@ -1,6 +1,9 @@
 import type { paths } from '@cloudtak/api-types';
 import type { Router } from 'vue-router';
+export declare const serverUrl: string;
 export declare const server: import("openapi-fetch").Client<paths, `${string}/${string}`>;
+export declare function getServer(): Promise<import("openapi-fetch").Client<paths, `${string}/${string}`>>;
+export declare function getRuntimeToken(): Promise<string | undefined>;
 export declare function stdurl(url: string | URL): URL;
 /**
  * Standardize interactions with the backend API
@@ -15,5 +18,11 @@ export declare function std(url: string | URL, opts?: {
     body?: unknown;
     method?: string;
 }): Promise<unknown>;
-export declare function humanSeconds(seconds: number): string;
+export declare function downloadBlob(blob: Blob, response: Response, fallbackName: string): void;
+export declare function downloadUrl(url: string | URL, opts?: {
+    filename?: string;
+    token?: boolean;
+    native?: boolean;
+}): Promise<void>;
 export declare function stdclick($router: Router, event: MouseEvent | KeyboardEvent, path: string): void;
+export declare function humanSeconds(seconds: number): string;

package/dist/types/src/stores/device/camera.d.ts

@@ -0,0 +1,9 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare function checkNativeCameraPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+export declare function requestNativeCameraPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+export declare class CameraPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}

package/dist/types/src/stores/device/file-system.d.ts

@@ -0,0 +1,7 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class FileSystemPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}

package/dist/types/src/stores/device/geolocation.d.ts

@@ -0,0 +1,15 @@
+import type { CallbackID, Position, PositionOptions } from '@capacitor/geolocation';
+import type { DevicePermissionContext } from './types.ts';
+export declare function supportsLocationRequests(): boolean;
+export declare function checkNativeLocationPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+export declare function requestNativeLocationPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+export declare function getCurrentLocation(options?: PositionOptions): Promise<Position>;
+export declare function watchLocation(options: PositionOptions, callback: (position: Position | null, err?: unknown) => void): Promise<CallbackID>;
+export declare function clearLocationWatch(id: CallbackID): Promise<void>;
+export declare class GeolocationPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(onGranted?: () => void): Promise<void>;
+    initializeSubscription(onGranted?: () => void): Promise<void>;
+}

package/dist/types/src/stores/device/index.d.ts

@@ -0,0 +1,264 @@
+import { CameraPermission } from './camera.ts';
+import { FileSystemPermission } from './file-system.ts';
+import { GeolocationPermission } from './geolocation.ts';
+import { BrowserNotificationPermission } from './notification.ts';
+import { OrientationPermission } from './orientation.ts';
+import { StoragePermission } from './storage.ts';
+import { WakeLockPermission } from './wake-lock.ts';
+import type { BrowserPermissionState, BrowserPermissionType } from './types.ts';
+export type { BrowserPermissionState, BrowserPermissionType } from './types.ts';
+export { CameraPermission } from './camera.ts';
+export { FileSystemPermission } from './file-system.ts';
+export { GeolocationPermission } from './geolocation.ts';
+export { BrowserNotificationPermission } from './notification.ts';
+export { OrientationPermission } from './orientation.ts';
+export { StoragePermission } from './storage.ts';
+export { WakeLockPermission } from './wake-lock.ts';
+export declare const usePermissionStore: import("pinia").StoreDefinition<"permissions", Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, "notification" | "orientation" | "storage" | "permissions" | "camera" | "geolocation" | "wakeLock" | "fileSystem">, Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, never>, Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, "setPermissionStatus" | "refreshPermissionStatuses" | "initializePermissionSubscriptions" | "hasOrientationSupport" | "hasOrientationPermissionRequest" | "getOrientationEventName" | "getOrientationHeading" | "addOrientationListener" | "removeOrientationListener" | "refreshLocationPermissionStatus" | "refreshNotificationPermissionStatus" | "refreshOrientationPermissionStatus" | "refreshStoragePermissionStatus" | "refreshCameraPermissionStatus" | "refreshWakeLockPermissionStatus" | "refreshFileSystemPermissionStatus" | "requestLocationPermission" | "requestNotificationPermission" | "requestOrientationPermission" | "requestStoragePermission" | "requestCameraPermission" | "requestWakeLockPermission" | "requestFileSystemPermission" | "releaseWakeLockSentinel">>;
+export declare const useDeviceStore: import("pinia").StoreDefinition<"permissions", Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, "notification" | "orientation" | "storage" | "permissions" | "camera" | "geolocation" | "wakeLock" | "fileSystem">, Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, never>, Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, "setPermissionStatus" | "refreshPermissionStatuses" | "initializePermissionSubscriptions" | "hasOrientationSupport" | "hasOrientationPermissionRequest" | "getOrientationEventName" | "getOrientationHeading" | "addOrientationListener" | "removeOrientationListener" | "refreshLocationPermissionStatus" | "refreshNotificationPermissionStatus" | "refreshOrientationPermissionStatus" | "refreshStoragePermissionStatus" | "refreshCameraPermissionStatus" | "refreshWakeLockPermissionStatus" | "refreshFileSystemPermissionStatus" | "requestLocationPermission" | "requestNotificationPermission" | "requestOrientationPermission" | "requestStoragePermission" | "requestCameraPermission" | "requestWakeLockPermission" | "requestFileSystemPermission" | "releaseWakeLockSentinel">>;

package/dist/types/src/stores/device/notification.d.ts

@@ -0,0 +1,15 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class BrowserNotificationPermission {
+    private readonly context;
+    private messagingToken;
+    private tokenListener;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+    initializeSubscription(): Promise<void>;
+    getMessagingToken(): string | null;
+    refreshMessagingToken(): Promise<string | null>;
+    deleteMessagingToken(): Promise<void>;
+    private refreshNativeStatus;
+    private initializeNativeMessaging;
+}

package/dist/types/src/stores/device/orientation.d.ts

@@ -0,0 +1,15 @@
+import type { DevicePermissionContext } from './types.ts';
+type DeviceOrientationEventName = 'deviceorientationabsolute' | 'deviceorientation';
+export declare class OrientationPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    hasSupport(): boolean;
+    hasPermissionRequest(): boolean;
+    getEventName(): DeviceOrientationEventName;
+    getHeading(event: DeviceOrientationEvent): number | null;
+    addListener(listener: (event: DeviceOrientationEvent) => void): void;
+    removeListener(listener: (event: DeviceOrientationEvent) => void): void;
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}
+export {};

package/dist/types/src/stores/device/shared.d.ts

@@ -0,0 +1,2 @@
+export declare function hasPermissionQuery(): boolean;
+export declare function queryPermissionStatus(name: string, warning: string): Promise<PermissionStatus | null>;

package/dist/types/src/stores/device/storage.d.ts

@@ -0,0 +1,7 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class StoragePermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}

package/dist/types/src/stores/device/types.d.ts

@@ -0,0 +1,23 @@
+export type BrowserPermissionState = PermissionState | 'unsupported' | 'unknown';
+export type BrowserPermissionType = 'location' | 'notification' | 'orientation' | 'storage' | 'camera' | 'wakeLock' | 'fileSystem';
+export type FileSystemAccessHandle = FileSystemHandle & {
+    queryPermission?: (descriptor?: {
+        mode?: 'read' | 'readwrite';
+    }) => Promise<PermissionState>;
+    requestPermission?: (descriptor?: {
+        mode?: 'read' | 'readwrite';
+    }) => Promise<PermissionState>;
+};
+export type WindowWithFilePicker = Window & {
+    showOpenFilePicker?: (options?: {
+        multiple?: boolean;
+    }) => Promise<FileSystemAccessHandle[]>;
+};
+export interface DevicePermissionContext {
+    permissions: Record<BrowserPermissionType, BrowserPermissionState>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    getWakeLockSentinel: () => WakeLockSentinel | null;
+    setWakeLockSentinel: (sentinel: WakeLockSentinel | null) => void;
+    getFileSystemHandle: () => FileSystemAccessHandle | null;
+    setFileSystemHandle: (handle: FileSystemAccessHandle | null) => void;
+}

package/dist/types/src/stores/device/wake-lock.d.ts

@@ -0,0 +1,10 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class WakeLockPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+    releaseSentinel(): Promise<void>;
+    private isSupported;
+    private isKeptAwake;
+}

package/dist/types/src/stores/map.d.ts

@@ -6,7 +6,6 @@ import * as Comlink from 'comlink';
 import COT from '../base/cot.ts';
 import type { DatabaseType } from '../database.ts';
 import { LocationState } from '../base/events.ts';
-import Overlay from '../base/overlay.ts';
 import Subscription from '../base/subscription.ts';
 import * as mapgl from 'maplibre-gl';
 import type Atlas from '../workers/atlas.ts';
@@ -56,6 +55,7 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     };
     timer: ReturnType<typeof setInterval> | null;
     _rawWorker: Worker;
+    _workerReady: Promise<void>;
     worker: Comlink.Remote<Atlas>;
     mission: Subscription | undefined;
     terrainEnabled: boolean;
@@ -84,7 +84,6 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
         y: number;
         lngLat?: LngLat;
     };
-    overlays: Array<Overlay>;
 }, {
     map: () => mapgl.Map;
     draw: () => DrawTool;
@@ -93,13 +92,7 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     bottomBar: () => BottomBarManager;
 }, {
     destroy: () => Promise<void>;
-    getOverlayBeforeId: () => string | undefined;
-    addOverlay: (overlay: Overlay) => void;
-    removeOverlay: (overlay: Overlay) => Promise<void>;
     makeActiveMission: (mission?: Subscription) => Promise<void>;
-    getOverlayById(id: number): Overlay | null;
-    getOverlayByName(name: string): Overlay | null;
-    getOverlayByMode(mode: string, mode_id: string): Overlay | null;
     addTerrain: () => Promise<void>;
     removeTerrain: () => void;
     returnHome: () => Promise<void>;

package/dist/types/src/stores/modules/icons.d.ts

@@ -1,17 +1,14 @@
 import type { Map as MapLibreMap } from 'maplibre-gl';
-import type * as Comlink from 'comlink';
-import type Atlas from '../../workers/atlas.ts';
 import { type DBIconset } from '../../database.ts';
 export default class IconManager {
     private cache;
     private map;
-    private worker;
     private loggedMissingImageIds;
     private loggedErrors;
     private inflightImage;
     private fallbackBitmap;
     private requestedIconsetImageIds;
-    constructor(map: MapLibreMap, worker: Comlink.Remote<Atlas>);
+    constructor(map: MapLibreMap);
     private logWarnOnce;
     private logErrorOnce;
     static from(uid: string): Promise<DBIconset | undefined>;
@@ -39,9 +36,8 @@ export default class IconManager {
     /**
      * Hydrate the local Dexie icon cache from the API.
      *
-     * The actual network IO and base64 -> Blob decoding runs inside the Atlas
-     * worker (see `AtlasIcons.hydrate`); this method only handles main-thread
-     * concerns like purging stale MapLibre images.
+     * This method also handles main-thread concerns like purging stale MapLibre
+     * images when the local Dexie cache changes.
      */
     hydrate(opts?: {
         force?: boolean;
@@ -55,6 +51,7 @@ export default class IconManager {
         force?: boolean;
     }): Promise<void>;
     removeIconset(uid: string): Promise<void>;
+    deleteIconset(uid: string): Promise<void>;
     private applyHydrateResult;
     private purgeMapImagesForIconset;
     onStyleImageMissing(e: {