@tak-ps/cloudtak 13.84.2 → 13.85.0

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

@@ -33,8 +33,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         default: number;
     };
 }>> & Readonly<{}>, {
-    stroke: number;
     size: number;
+    stroke: number;
     title: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;

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

@@ -101,9 +101,9 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onDelete?: ((...args: any[]) => any) | undefined;
 }>, {
-    stroke: number;
     mode: string;
     size: number;
+    stroke: number;
     label: string;
     rows: number;
     hover: boolean;

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

@@ -25,8 +25,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         default: number;
     };
 }>> & Readonly<{}>, {
-    labels: boolean;
     iconset: string;
+    labels: boolean;
     refreshKey: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;

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

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

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

@@ -34,8 +34,8 @@ declare const __VLS_export: import("vue").DefineComponent<Props, {
         name: string;
     }) => any) | undefined;
 }>, {
-    method: string;
     cancel: boolean;
+    method: string;
     headers: Record<string, string>;
     label: string;
     format: "formdata" | "raw";

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

@@ -12,12 +12,12 @@ type __VLS_Props = {
     lease?: number;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    metadata: (metadata: VideoPlayerMetadata) => any;
     error: (error: Error) => any;
+    metadata: (metadata: VideoPlayerMetadata) => any;
     protocol: (protocol: PlaybackProtocol) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onMetadata?: ((metadata: VideoPlayerMetadata) => any) | undefined;
     onError?: ((error: Error) => any) | undefined;
+    onMetadata?: ((metadata: VideoPlayerMetadata) => any) | undefined;
     onProtocol?: ((protocol: PlaybackProtocol) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

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

@@ -242,12 +242,33 @@ export type DatabaseType = Dexie & {
 };
 export declare const db: DatabaseType;
 export declare function ensureDatabase(): Promise<void>;
+/** Thrown for any IndexedDB access while suspendDatabase() is in effect */
+export declare class DatabaseSuspendedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * The storage process did not answer a bounded probe. Every read and write
+ * would hang forever; only a fresh WebView (or app process) recovers.
+ */
+export declare class DatabaseUnavailableError extends Error {
+    constructor(message: string);
+}
+export declare function isDatabaseSuspended(): boolean;
 /**
- * Probe the IndexedDB connection with a real read and reopen it if needed.
- * An iOS suspend can invalidate the connection without a close event -
- * db.isOpen() still reports true while every request wedges - so a failed
- * probe forces an explicit close before reopening.
+ * Reject every IndexedDB transaction synchronously, before an
+ * IDBTransaction is opened, so nothing is ever in flight while the app is
+ * backgrounded. A closed database is not reopened until resumeDatabase().
  */
-export declare function recoverDatabase(probeTimeoutMs?: number): Promise<void>;
+export declare function suspendDatabase(): void;
+export declare function resumeDatabase(): void;
+export declare function deferFeaturePersist(id: string): void;
+export declare function takeDeferredFeatureIds(): string[];
 export declare function isTransientDbError(err: unknown): boolean;
 export declare function withDbRetry<T>(fn: () => Promise<T>, attempts?: number): Promise<T>;
+/**
+ * Bounded round trip to the storage process. A wedged IndexedDB (see
+ * suspendDatabase()) never answers, so callers on a boot path use this to
+ * fail in seconds with a DatabaseUnavailableError instead of hanging until
+ * their own, much longer, stage timeout.
+ */
+export declare function probeDatabase(timeoutMs: number): Promise<void>;

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

@@ -12,7 +12,6 @@ export declare const useAppStore: import("pinia").StoreDefinition<"cloudtak-app"
     loadingStage: string;
 }, {}, {
     setServerUrl(serverUrl: string): Promise<void>;
-    mirrorServerUrl(serverUrl: string): Promise<void>;
     persistSession(opts: {
         token: string;
         username: string;

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

@@ -28,9 +28,8 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     _menu?: unknown;
     _bottomBar?: unknown;
     _removeOrientationListener?: () => Promise<void>;
-    _resumeRecovery?: Promise<void>;
     _cotResync?: Promise<void>;
-    _removeBackgroundStateListener?: () => void;
+    _destroying?: Promise<void>;
     _removePushTokenListener?: () => void;
     _overlaySubscription?: {
         unsubscribe: () => void;
@@ -67,13 +66,13 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     coordFormat: string;
     defaultPointType: string;
     manualLocationMode: boolean;
-    isBackgrounded: boolean;
     lastUpdateCOTErrorSignature: string | null;
     toastOffset: {
         x: number;
         y: number;
     };
     timer: ReturnType<typeof setInterval> | null;
+    backgrounded: boolean;
     _rawWorker?: Worker;
     _workerReady?: Promise<void>;
     _worker?: Comlink.Remote<Atlas>;
@@ -127,7 +126,17 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     reverseNavigation: () => void;
     openSelfFeature: () => Promise<void>;
     startWorker: () => void;
+    startRefreshTimer: () => void;
+    /**
+     * Native app moved to the background: stop every IndexedDB touch on
+     * both threads. iOS kills WKWebView's storage process under a
+     * backgrounded app and a request caught in flight wedges storage for
+     * the life of the WebView - see suspendDatabase().
+     */
+    suspend: () => Promise<void>;
+    resume: () => Promise<void>;
     destroy: () => Promise<void>;
+    _destroy: () => Promise<void>;
     makeActiveMission: (mission?: Subscription) => Promise<void>;
     terrainOverlay: () => Overlay | undefined;
     toggleTerrain: () => Promise<void>;
@@ -145,9 +154,9 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     updateCOT: () => Promise<void>;
     /**
      * Rebuild the CoT GeoJSON source wholesale from the worker's full
-     * feature state. Used on app resume and as recovery whenever an
-     * incremental diff was consumed from the worker but failed to apply -
-     * without this those features would never render again.
+     * feature state. Recovery whenever an incremental diff was consumed
+     * from the worker but failed to apply - without this those features
+     * would never render again.
      */
     resyncCOT: () => Promise<void>;
     /**
@@ -162,11 +171,6 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     loadMission: (guid: string, opts?: {
         reload: boolean;
     }) => Promise<Subscription | null>;
-    /**
-     * Recover IndexedDB connections and the TAK WebSocket after the app
-     * returns to the foreground.
-     */
-    resumeFromBackground: () => Promise<void>;
     init: (container: HTMLElement) => Promise<void>;
     initOverlays: () => Promise<void>;
     /**

package/dist/types/src/utils/capacitor.d.ts

@@ -21,3 +21,12 @@ export declare function addBackButtonListener(handler: () => void): Promise<() =
 export declare function minimizeApp(): Promise<void>;
 export declare function openExternalUrl(url: string | URL): Promise<void>;
 export declare function openSecondaryView(url: string | URL): Promise<void>;
+/**
+ * Subscribe to native background (pause) and foreground (resume)
+ * transitions. Unlike appStateChange these do not fire for transient
+ * inactivity such as Control Center. Returns a no-op remover on web.
+ */
+export declare function addAppLifecycleListeners(handlers: {
+    pause?: () => void;
+    resume?: () => void;
+}): Promise<() => void>;

package/dist/types/src/utils/worker-boot.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Session handed to a dedicated worker through `Worker.name`, readable
+ * synchronously as `self.name` during module evaluation. The Atlas worker
+ * used to resolve its server URL from IndexedDB at import time, which on
+ * native could hang the worker before it ever signalled ready.
+ */
+export type WorkerBootConfig = {
+    serverUrl?: string;
+};
+export declare function serializeWorkerBootConfig(config: WorkerBootConfig): string;
+export declare function parseWorkerBootConfig(name: string | null | undefined): WorkerBootConfig | undefined;

package/dist/types/src/workers/atlas-connection.d.ts

@@ -10,14 +10,6 @@ export default class AtlasConnection {
     version: string;
     private reconnectTimer;
     constructor(atlas: Atlas);
-    reconnect(connection: string): void;
-    /**
-     * Called when the app returns to the foreground. iOS suspension can kill
-     * the TCP connection with no FIN reaching the client (NAT/LB idle
-     * timeout), so no close event ever fires and `isOpen` cannot be trusted -
-     * always rebuild the socket unless the user has logged out.
-     */
-    resume(connection: string): void;
     connect(connection: string): void;
     private scheduleReconnect;
     private isAuthRejected;

package/dist/types/src/workers/atlas-database.d.ts

@@ -106,6 +106,11 @@ export default class AtlasDatabase {
      * still in flight is never removed.
      */
     loadArchive(): Promise<void>;
+    /**
+     * Persist features whose IndexedDB write was skipped while the database
+     * was suspended (app backgrounded on native). Returns the number written.
+     */
+    flushDeferred(): Promise<number>;
     /**
      * Remove a given CoT from the store
      *

package/dist/types/src/workers/atlas-profile.d.ts

@@ -33,6 +33,8 @@ export default class AtlasProfile {
     hasNoConfiguration(): boolean;
     hasNoChannels(): Promise<boolean>;
     destroy(): void;
+    /** Stop the periodic self CoT; setupTimer() restarts it */
+    pauseTimer(): void;
     setupTimer(): void;
     loadServer(): Promise<Server>;
     load(): Promise<void>;

package/dist/types/src/workers/atlas.d.ts

@@ -10,6 +10,7 @@ export default class Atlas {
     token: string;
     username: string;
     initialized: boolean;
+    suspended: boolean;
     db: AtlasDatabase & Comlink.ProxyMarked;
     conn: AtlasConnection & Comlink.ProxyMarked;
     profile: AtlasProfile & Comlink.ProxyMarked;
@@ -17,11 +18,14 @@ export default class Atlas {
     tiles: AtlasTiles & Comlink.ProxyMarked;
     constructor();
     postMessage(msg: WorkerMessage): Promise<void>;
+    init(authToken: string): Promise<void>;
     /**
-     * Called by the main thread on app resume - workers receive no
-     * visibility events to recover their own IndexedDB connection.
+     * Native background: keep the WebSocket, stop every IndexedDB touch.
+     * iOS kills WKWebView's storage process under a backgrounded app and a
+     * request caught in flight wedges storage for the life of the WebView.
+     * Features that arrive meanwhile stay in memory and persist on resume.
      */
-    recover(): Promise<void>;
-    init(authToken: string): Promise<void>;
+    suspend(): void;
+    resume(): Promise<void>;
     destroy(): void;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/cloudtak",
     "type": "module",
-    "version": "13.84.2",
+    "version": "13.85.0",
     "types": "dist/types/plugin.d.ts",
     "files": [
         "dist/types"