screenhand 0.1.1 → 0.3.0

package/dist/src/state/entity-tracker.js

@@ -0,0 +1,108 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+import crypto from "node:crypto";
+const MAX_POSITIONS = 10;
+const PROXIMITY_THRESHOLD = 50; // pixels
+/**
+ * EntityTracker — persistent cross-frame identity for UI elements.
+ *
+ * A panel that moves 10px between frames keeps the same entityId
+ * instead of getting a new stableId (which includes quantized position).
+ * Matches by label similarity + position proximity.
+ */
+export class EntityTracker {
+    entities = new Map();
+    /**
+     * Match an incoming element to an existing entity, or create a new one.
+     * Fuzzy match by label (exact) + window scope + position proximity (within threshold).
+     */
+    matchOrCreate(type, label, position, windowId) {
+        const now = new Date().toISOString();
+        // Try to find an existing entity with the same label, window, and nearby position
+        for (const entity of this.entities.values()) {
+            if (entity.type !== type || entity.label !== label)
+                continue;
+            if (entity.windowId !== windowId)
+                continue;
+            // Check position proximity against last known position
+            const lastPos = entity.positions[entity.positions.length - 1];
+            if (lastPos) {
+                const dx = Math.abs(lastPos.x - position.x);
+                const dy = Math.abs(lastPos.y - position.y);
+                if (dx <= PROXIMITY_THRESHOLD && dy <= PROXIMITY_THRESHOLD) {
+                    // Match found — update position history
+                    entity.lastSeen = now;
+                    entity.positions.push({ x: position.x, y: position.y, timestamp: now });
+                    if (entity.positions.length > MAX_POSITIONS) {
+                        entity.positions = entity.positions.slice(-MAX_POSITIONS);
+                    }
+                    return entity;
+                }
+            }
+            else {
+                // No position history (e.g. after rehydrate with empty positions) —
+                // match by label+type+window alone, and seed the position
+                entity.lastSeen = now;
+                entity.positions.push({ x: position.x, y: position.y, timestamp: now });
+                return entity;
+            }
+        }
+        // No match — create new entity
+        const entityId = crypto.randomUUID();
+        const entity = {
+            entityId,
+            type,
+            label,
+            windowId,
+            stableIds: [],
+            firstSeen: now,
+            lastSeen: now,
+            positions: [{ x: position.x, y: position.y, timestamp: now }],
+            properties: {},
+        };
+        this.entities.set(entityId, entity);
+        return entity;
+    }
+    /**
+     * Get entities filtered by type.
+     */
+    getByType(type) {
+        return [...this.entities.values()].filter((e) => e.type === type);
+    }
+    /**
+     * Get all tracked entities.
+     */
+    getAll() {
+        return new Map(this.entities);
+    }
+    /**
+     * Remove entities not seen within maxAgeMs.
+     */
+    pruneStale(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        let pruned = 0;
+        for (const [id, entity] of this.entities) {
+            if (new Date(entity.lastSeen).getTime() < cutoff) {
+                this.entities.delete(id);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    /**
+     * Rehydrate internal state from persisted entities.
+     * Clears current state first to avoid duplication.
+     */
+    rehydrate(entities) {
+        this.entities.clear();
+        for (const [id, entity] of entities) {
+            this.entities.set(id, { ...entity, positions: [...entity.positions] });
+        }
+    }
+    /**
+     * Clear all entities.
+     */
+    clear() {
+        this.entities.clear();
+    }
+}

package/dist/src/state/fusion.js

@@ -0,0 +1,96 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+/** Clamp confidence to [0, 1], replacing NaN/Infinity with a safe default. */
+function sanitizeConfidence(c) {
+    if (isNaN(c) || !isFinite(c))
+        return 0.5;
+    return Math.max(0, Math.min(1, c));
+}
+/**
+ * FusionPipeline — unified ingestion point that queues source updates
+ * and flushes them into the world model in timestamp order.
+ *
+ * Benefits over direct ingest calls:
+ * - Deduplication by source+windowId (keeps latest per source+window)
+ * - Timestamp-ordered processing
+ * - Learning-adaptive confidence via LearningEngine
+ */
+const MAX_QUEUE_SIZE = 100;
+export class FusionPipeline {
+    queue = [];
+    learningEngine = null;
+    setLearningEngine(engine) {
+        this.learningEngine = engine;
+    }
+    /**
+     * Enqueue a source update for batch processing.
+     */
+    enqueue(update) {
+        // Sanitize confidence: clamp to [0, 1], replace NaN with 0.5
+        update.confidence = sanitizeConfidence(update.confidence);
+        // Deduplicate: if there's already an update for the same source+windowId,
+        // keep the newer one (by timestamp)
+        const existingIdx = this.queue.findIndex((u) => u.source === update.source && u.windowId === update.windowId);
+        if (existingIdx >= 0) {
+            const existing = this.queue[existingIdx];
+            if (update.timestamp >= existing.timestamp) {
+                this.queue[existingIdx] = update;
+            }
+            // else: existing is newer, drop the incoming
+            return;
+        }
+        // Cap queue size to prevent unbounded growth during slow flushes
+        if (this.queue.length >= MAX_QUEUE_SIZE) {
+            // Drop oldest non-deduplicated entry
+            this.queue.shift();
+        }
+        this.queue.push(update);
+    }
+    /**
+     * Process all queued updates in timestamp order and flush into the world model.
+     */
+    flush(worldModel) {
+        if (this.queue.length === 0)
+            return;
+        // Sort by timestamp
+        this.queue.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        for (const update of this.queue) {
+            // Resolve adaptive confidence and apply it to the update
+            update.confidence = this.resolveConfidence(update);
+            if (update.source === "ax" && update.axTree && update.appContext) {
+                worldModel.ingestAXTree(update.windowId, update.axTree, update.appContext, update.confidence);
+            }
+            else if (update.source === "ocr" && update.ocrRegions) {
+                worldModel.ingestOCRRegions(update.windowId, update.ocrRegions, update.confidence);
+            }
+            else if (update.source === "cdp" && update.cdpSnapshot) {
+                worldModel.ingestCDPSnapshot(update.cdpSnapshot.bundleId, update.cdpSnapshot.url, update.cdpSnapshot.title, update.windowId);
+            }
+        }
+        this.queue = [];
+    }
+    /**
+     * Get the number of queued updates.
+     */
+    get size() {
+        return this.queue.length;
+    }
+    /**
+     * Resolve source confidence — use learning engine if available,
+     * otherwise fall back to hardcoded defaults.
+     */
+    resolveConfidence(update) {
+        if (!this.learningEngine)
+            return sanitizeConfidence(update.confidence);
+        // Get bundleId from the update context
+        const bundleId = update.appContext?.bundleId ?? update.cdpSnapshot?.bundleId;
+        if (!bundleId)
+            return sanitizeConfidence(update.confidence);
+        const ranked = this.learningEngine.rankSensors(bundleId);
+        const match = ranked.find((r) => r.sourceType === update.source);
+        if (match && match.score > 0) {
+            return sanitizeConfidence(match.score);
+        }
+        return sanitizeConfidence(update.confidence);
+    }
+}

package/dist/src/state/index.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+export { WorldModel } from "./world-model.js";
+export { EntityTracker } from "./entity-tracker.js";
+export { AppMap } from "./app-map.js";
+export { DEFAULT_APP_MAP_CONFIG, RATING_GRADES, RATING_FACTOR_WEIGHTS, GRADE_THRESHOLDS, ratingToString, } from "./app-map-types.js";
+export { generateLadderFromReference } from "./ladder-generator.js";

package/dist/src/state/ladder-generator.js

@@ -0,0 +1,236 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+// ── Keyword sets for level assignment ────────────────────────────
+const BEGINNER_KEYWORDS = new Set([
+    "navigation", "browse", "basic", "search", "header", "page", "nav", "home",
+    "page_header", "quick_find",
+]);
+const PRO_KEYWORDS = new Set([
+    "settings", "create", "views", "sort", "filter", "template", "new", "sidebar",
+    "create_new", "slash_commands", "notification", "preferences",
+]);
+const EXPERT_KEYWORDS = new Set([
+    "database", "admin", "moderation", "permissions", "automation", "advanced",
+    "server", "import", "export", "workflow", "security", "form",
+]);
+const GRANDMASTER_KEYWORDS = new Set([
+    "ai", "api", "integration", "custom", "governance", "crisis", "identity",
+    "billing", "orchestrat", "pipeline",
+]);
+// ── Stop words to exclude from signal keywords ───────────────────
+const STOP_WORDS = new Set([
+    "the", "a", "an", "in", "to", "or", "and", "at", "for", "of", "is", "on",
+    "by", "it", "if", "be", "as", "this", "that", "with", "from", "then",
+    "via", "e.g.", "etc", "note", "use",
+]);
+// ── Selector groups to skip (not real features) ──────────────────
+const SKIP_GROUPS = new Set(["auto_discovered"]);
+// ── Main: Generate ladder from reference ─────────────────────────
+export function generateLadderFromReference(ref) {
+    const features = [];
+    const signals = {};
+    const selectorGroups = ref.selectors ?? {};
+    const flows = ref.flows ?? {};
+    // Minimum threshold: need at least 2 meaningful selector groups
+    const meaningfulGroups = Object.keys(selectorGroups).filter(k => !SKIP_GROUPS.has(k));
+    if (meaningfulGroups.length < 2 && Object.keys(flows).length < 2) {
+        return { ladder: [], signals: {}, hash: computeHash(ref) };
+    }
+    // Track which flow names are already covered by selector groups
+    const coveredFlows = new Set();
+    // ── Step 1: Features from selector groups ──────────────────────
+    for (const groupName of meaningfulGroups) {
+        const sels = selectorGroups[groupName];
+        const selCount = Object.keys(sels).length;
+        const level = assignLevel(groupName, selCount, false, 0);
+        const weight = assignWeight(groupName, selCount, level);
+        const critical = selCount >= 6 || weight === 3;
+        const featureId = groupName;
+        const description = describeFeature(groupName, sels);
+        features.push({ id: featureId, description, level, weight, critical });
+        // Generate signal keywords from selector keys and values
+        const keywords = extractKeywordsFromSelectors(groupName, sels);
+        signals[featureId] = keywords;
+        // Mark related flows as covered
+        for (const flowName of Object.keys(flows)) {
+            if (flowNamesRelated(groupName, flowName)) {
+                coveredFlows.add(flowName);
+                // Merge flow keywords into this feature's signals
+                const flowKw = extractKeywordsFromFlow(flowName, flows[flowName]);
+                signals[featureId] = deduplicateArray([...signals[featureId], ...flowKw]);
+            }
+        }
+    }
+    // ── Step 2: Additional features from uncovered flows ───────────
+    for (const [flowName, flow] of Object.entries(flows)) {
+        if (coveredFlows.has(flowName))
+            continue;
+        const stepCount = flow.steps?.length ?? 0;
+        const guardCount = flow.guards?.length ?? 0;
+        const level = assignLevel(flowName, 0, true, stepCount + guardCount);
+        const weight = assignWeight(flowName, stepCount, level);
+        const critical = guardCount >= 2 || weight === 3;
+        const featureId = flowName;
+        const description = flow.steps?.[0] ?? `${flowName.replace(/_/g, " ")} workflow`;
+        features.push({ id: featureId, description, level, weight, critical });
+        const keywords = extractKeywordsFromFlow(flowName, flow);
+        signals[featureId] = keywords;
+    }
+    // ── Step 3: Sort by level progression ──────────────────────────
+    const levelOrder = {
+        beginner: 0, pro: 1, expert: 2, grandmaster: 3,
+    };
+    features.sort((a, b) => levelOrder[a.level] - levelOrder[b.level]);
+    return { ladder: features, signals, hash: computeHash(ref) };
+}
+// ── Level assignment heuristics ──────────────────────────────────
+function assignLevel(name, selectorCount, isFlow, complexity) {
+    const nameLower = name.toLowerCase();
+    const parts = nameLower.split(/[_\s-]+/);
+    // Check grandmaster first (most specific)
+    if (parts.some(p => GRANDMASTER_KEYWORDS.has(p)))
+        return "grandmaster";
+    if (parts.some(p => EXPERT_KEYWORDS.has(p)))
+        return "expert";
+    if (parts.some(p => PRO_KEYWORDS.has(p)))
+        return "pro";
+    if (parts.some(p => BEGINNER_KEYWORDS.has(p)))
+        return "beginner";
+    // Fallback based on complexity
+    if (isFlow) {
+        if (complexity >= 8)
+            return "expert";
+        if (complexity >= 5)
+            return "pro";
+        return "beginner";
+    }
+    // Selector group: more selectors = more complex
+    if (selectorCount >= 8)
+        return "expert";
+    if (selectorCount >= 4)
+        return "pro";
+    return "beginner";
+}
+// ── Weight assignment ────────────────────────────────────────────
+function assignWeight(name, complexity, level) {
+    if (level === "grandmaster")
+        return 3;
+    if (level === "expert" && complexity >= 6)
+        return 3;
+    if (level === "expert" || level === "pro")
+        return 2;
+    return 1;
+}
+// ── Description generation ───────────────────────────────────────
+function describeFeature(groupName, sels) {
+    const humanName = groupName.replace(/_/g, " ");
+    const selNames = Object.keys(sels).slice(0, 3).map(k => k.replace(/_/g, " ")).join(", ");
+    return `${humanName}: ${selNames}`;
+}
+// ── Keyword extraction from selectors ────────────────────────────
+function extractKeywordsFromSelectors(groupName, sels) {
+    const keywords = [];
+    // Add group name parts
+    for (const part of groupName.split("_")) {
+        if (!STOP_WORDS.has(part.toLowerCase()) && part.length > 1) {
+            keywords.push(part.toLowerCase());
+        }
+    }
+    // Add selector key parts
+    for (const key of Object.keys(sels)) {
+        for (const part of key.split("_")) {
+            const lower = part.toLowerCase();
+            if (!STOP_WORDS.has(lower) && lower.length > 2) {
+                keywords.push(lower);
+            }
+        }
+    }
+    // Extract significant words from selector values
+    for (const val of Object.values(sels)) {
+        // Extract quoted text: 'text' or "text"
+        const quoted = val.match(/['"]([^'"]{2,20})['"]/g);
+        if (quoted) {
+            for (const q of quoted) {
+                const clean = q.replace(/['"]/g, "").toLowerCase();
+                if (!STOP_WORDS.has(clean))
+                    keywords.push(clean);
+            }
+        }
+        // Extract shortcut keys like Cmd+K
+        const shortcuts = val.match(/Cmd\+\S+/gi);
+        if (shortcuts) {
+            for (const s of shortcuts)
+                keywords.push(s.toLowerCase());
+        }
+    }
+    return deduplicateArray(keywords);
+}
+// ── Keyword extraction from flows ────────────────────────────────
+function extractKeywordsFromFlow(flowName, flow) {
+    const keywords = [];
+    // Flow name parts
+    for (const part of flowName.split("_")) {
+        if (!STOP_WORDS.has(part.toLowerCase()) && part.length > 1) {
+            keywords.push(part.toLowerCase());
+        }
+    }
+    // Extract from steps
+    if (flow.steps) {
+        for (const step of flow.steps) {
+            // Extract quoted text
+            const quoted = step.match(/['"]([^'"]{2,25})['"]/g);
+            if (quoted) {
+                for (const q of quoted) {
+                    const clean = q.replace(/['"]/g, "").toLowerCase();
+                    if (!STOP_WORDS.has(clean) && clean.length > 2)
+                        keywords.push(clean);
+                }
+            }
+            // Extract shortcut keys
+            const shortcuts = step.match(/Cmd\+\S+/gi);
+            if (shortcuts) {
+                for (const s of shortcuts)
+                    keywords.push(s.toLowerCase());
+            }
+            // Extract action verbs and significant nouns
+            const words = step.split(/\s+/);
+            for (const w of words) {
+                const lower = w.toLowerCase().replace(/[^a-z0-9+]/g, "");
+                if (lower.length > 3 && !STOP_WORDS.has(lower)) {
+                    keywords.push(lower);
+                }
+            }
+        }
+    }
+    return deduplicateArray(keywords);
+}
+// ── Flow-to-selector group name matching ─────────────────────────
+function flowNamesRelated(groupName, flowName) {
+    const gParts = new Set(groupName.split("_"));
+    const fParts = flowName.split("_");
+    // At least 50% of flow name parts match group name parts
+    const matches = fParts.filter(p => gParts.has(p)).length;
+    if (matches >= Math.ceil(fParts.length * 0.5))
+        return true;
+    // Direct substring match
+    if (groupName.includes(flowName) || flowName.includes(groupName))
+        return true;
+    return false;
+}
+// ── Hash computation for cache invalidation ──────────────────────
+function computeHash(ref) {
+    const keys = [
+        ...Object.keys(ref.selectors ?? {}).sort(),
+        ...Object.keys(ref.flows ?? {}).sort(),
+    ].join("|");
+    // Simple string hash (djb2)
+    let hash = 5381;
+    for (let i = 0; i < keys.length; i++) {
+        hash = ((hash << 5) + hash + keys.charCodeAt(i)) | 0;
+    }
+    return `ref_${Math.abs(hash).toString(36)}`;
+}
+// ── Utilities ────────────────────────────────────────────────────
+function deduplicateArray(arr) {
+    return [...new Set(arr)];
+}

package/dist/src/state/persistence.js

@@ -0,0 +1,156 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { writeFileAtomicSync, readJsonWithRecovery } from "../util/atomic-write.js";
+const DEFAULT_STATE_DIR = path.join(os.homedir(), ".screenhand", "state");
+function stateFilePath(stateDir, sessionId) {
+    // Sanitize sessionId to prevent path traversal
+    const safeId = sessionId.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    const filePath = path.join(stateDir, `${safeId}.json`);
+    // Double-check the resolved path stays inside stateDir
+    const resolved = path.resolve(filePath);
+    if (!resolved.startsWith(path.resolve(stateDir))) {
+        return path.join(stateDir, "invalid_session.json");
+    }
+    return filePath;
+}
+export function worldStateToJSON(state) {
+    const serialized = {
+        windows: Object.fromEntries(Array.from(state.windows.entries()).map(([id, win]) => [
+            String(id),
+            {
+                ...win,
+                controls: Object.fromEntries(win.controls),
+            },
+        ])),
+        focusedWindowId: state.focusedWindowId,
+        focusedApp: state.focusedApp,
+        activeDialogs: state.activeDialogs.map((d) => ({
+            ...d,
+            controls: Object.fromEntries(d.controls),
+        })),
+        appDomains: Object.fromEntries(state.appDomains),
+        lastFullScan: state.lastFullScan,
+        sessionId: state.sessionId,
+        expectedPostcondition: state.expectedPostcondition,
+        updatedAt: state.updatedAt,
+        confidence: state.confidence,
+        pendingGoal: state.pendingGoal,
+        recentTransitions: state.recentTransitions,
+        trackedEntities: Object.fromEntries(state.trackedEntities),
+    };
+    return JSON.stringify(serialized);
+}
+export function worldStateFromJSON(json) {
+    const windows = new Map();
+    for (const [idStr, win] of Object.entries(json.windows ?? {})) {
+        windows.set(Number(idStr), {
+            ...win,
+            controls: new Map(Object.entries(win.controls)),
+            // Defaults for new WindowState fields (backwards compat)
+            focusedElement: win.focusedElement ?? null,
+            visibleControls: win.visibleControls ?? [],
+            dialogStack: win.dialogStack ?? [],
+            scrollPosition: win.scrollPosition ?? null,
+            lastAXScanAt: win.lastAXScanAt ?? null,
+            lastCDPScanAt: win.lastCDPScanAt ?? null,
+            lastOCRAt: win.lastOCRAt ?? null,
+            lastScreenshotHash: win.lastScreenshotHash ?? null,
+        });
+    }
+    const activeDialogs = (json.activeDialogs ?? []).map((d) => ({
+        ...d,
+        controls: new Map(Object.entries(d.controls)),
+        // Defaults for new DialogState fields (backwards compat)
+        message: d.message ?? null,
+        buttons: d.buttons ?? [],
+        source: d.source ?? "ax",
+    }));
+    const appDomains = new Map(Object.entries(json.appDomains ?? {}));
+    return {
+        windows,
+        focusedWindowId: json.focusedWindowId,
+        focusedApp: json.focusedApp,
+        activeDialogs,
+        appDomains,
+        lastFullScan: json.lastFullScan,
+        sessionId: json.sessionId,
+        expectedPostcondition: json.expectedPostcondition ?? null,
+        updatedAt: json.updatedAt ?? json.lastFullScan,
+        confidence: json.confidence ?? 1.0,
+        pendingGoal: json.pendingGoal ?? null,
+        recentTransitions: json.recentTransitions ?? [],
+        trackedEntities: new Map(Object.entries(json.trackedEntities ?? {})),
+    };
+}
+export function saveWorldState(state, stateDir) {
+    const dir = stateDir ?? DEFAULT_STATE_DIR;
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = stateFilePath(dir, state.sessionId);
+    writeFileAtomicSync(filePath, worldStateToJSON(state));
+}
+export function loadWorldState(sessionId, stateDir) {
+    const dir = stateDir ?? DEFAULT_STATE_DIR;
+    const filePath = stateFilePath(dir, sessionId);
+    const raw = readJsonWithRecovery(filePath);
+    if (!raw)
+        return null;
+    return worldStateFromJSON(raw);
+}
+export class DebouncedPersister {
+    timer = null;
+    pending = null;
+    saveFn;
+    constructor(debounceMs, saveFn) {
+        this.saveFn = saveFn ?? ((s) => saveWorldState(s));
+        if (debounceMs <= 0) {
+            // Zero debounce = no-op persister (for tests)
+            this.schedule = () => { };
+            this.flush = () => { };
+            return;
+        }
+        // Store debounceMs for use in schedule
+        const ms = debounceMs;
+        this.schedule = (state) => {
+            this.pending = state;
+            if (this.timer)
+                return;
+            this.timer = setTimeout(() => {
+                this.timer = null;
+                if (this.pending) {
+                    this.saveFn(this.pending);
+                    this.pending = null;
+                }
+            }, ms);
+        };
+    }
+    schedule(_state) {
+        // Overridden in constructor when debounceMs > 0
+    }
+    flush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.pending) {
+            this.saveFn(this.pending);
+            this.pending = null;
+        }
+    }
+}

package/dist/src/state/types.js

@@ -0,0 +1,17 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+export {};