prompttest 1.4.0 → 1.5.1

package/dist/lib/adaptive-timing.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @module adaptive-timing
+ * @description Device-Aware Adaptive Dynamic Waiting & Auto-Profiling.
+ *
+ * Automatically balances test timing between ultra-fast physical devices (USB 3.0)
+ * and resource-constrained CI emulators (software-rendered VMs in GitHub Actions).
+ *
+ * Implements exponential backoff condition-driven polling with instant short-circuiting:
+ * fast devices finish immediately upon event completion, while slow emulators receive
+ * adaptive headroom without CPU exhaustion.
+ */
+import type { AndroidDriver } from './adb.js';
+export interface DeviceProfile {
+    /** Whether the target device is an emulator / virtual device */
+    isEmulator: boolean;
+    /** Whether the process is executing inside a CI / CD environment (e.g. GitHub Actions) */
+    isCI: boolean;
+    /** Calculated dynamic velocity multiplier (1.0 = real device, 1.5 = local emulator, 2.5 = CI) */
+    velocityMultiplier: number;
+    /** Default timeout ceiling for UI element detection */
+    defaultTimeoutMs: number;
+    /** Extended timeout ceiling for multi-step transitions and cold loads */
+    extendedTimeoutMs: number;
+    /** Minimum stability duration for dual-sample quiescence verification */
+    quiescenceSettleMs: number;
+    /** Initial polling interval in milliseconds */
+    initialPollMs: number;
+    /** Maximum backoff polling interval in milliseconds */
+    maxPollIntervalMs: number;
+}
+/**
+ * Probes the connected device and host runtime to construct an adaptive timing profile.
+ * Cached per session so that subsequent steps reuse the profiled characteristics.
+ *
+ * @param driver - Android driver instance
+ * @param serial - Optional target device serial
+ */
+export declare function profileDeviceEnvironment(driver: AndroidDriver, serial?: string): Promise<DeviceProfile>;
+/**
+ * Resets the cached device profile (primarily used in testing).
+ */
+export declare function resetDeviceProfile(): void;
+/**
+ * Polls an asynchronous condition using adaptive backoff with immediate short-circuiting.
+ *
+ * Fast devices short-circuit the instant the condition returns a truthy value.
+ * Slow emulators receive backoff polling that preserves CPU cycles for rendering.
+ *
+ * @param checkFn - Async callback returning a truthy value when the condition is met.
+ * @param timeoutMs - Maximum duration to wait before giving up.
+ * @param initialIntervalMs - Starting interval between checks.
+ * @param maxIntervalMs - Cap for the backoff interval.
+ * @returns The resolved value of the condition, or throws a timeout Error.
+ */
+export declare function pollWithAdaptiveBackoff<T>(checkFn: () => Promise<T | null | undefined | false>, timeoutMs: number, initialIntervalMs?: number, maxIntervalMs?: number): Promise<T>;

package/dist/lib/adb.d.ts

@@ -18,6 +18,8 @@ export interface AndroidDevice {
     model?: string;
     /** The product name of the device (optional) */
     product?: string;
+    /** Transport connection type: 'usb' | 'wifi' | 'emulator' */
+    connectionType?: 'usb' | 'wifi' | 'emulator';
 }
 export interface DeviceMetrics {
     battery?: {
@@ -42,6 +44,16 @@ export interface DeviceMetrics {
     };
 }
 export declare function parseDeviceMetrics(batteryOutput: string, displayOutput: string, memoryOutput: string, graphicsOutput: string): DeviceMetrics;
+/**
+ * Classifies a device connection type from its serial or model properties.
+ */
+export declare function classifyDeviceConnection(serial: string): 'usb' | 'wifi' | 'emulator';
+/**
+ * Deduplicates multiple transport connections for the same physical Android hardware.
+ * Priority: USB > Wi-Fi (IP:port) > Wi-Fi (mDNS) > Emulator.
+ * Prevents simultaneous execution collisions on the same physical phone.
+ */
+export declare function deduplicateDevices(devices: AndroidDevice[]): AndroidDevice[];
 /**
  * AndroidDriver is responsible for executing ADB commands and handling device interactions.
  * It manages the default targeted device, executes shell commands, extracts device state,
@@ -113,10 +125,23 @@ export declare class AndroidDriver {
      */
     execAdbBinary(args: readonly string[] | string[], serial?: string, timeoutMs?: number): Promise<Buffer>;
     /**
-     * Retrieves a list of currently connected Android devices and their statuses.
+    /**
+     * Retrieves all raw connected Android devices from ADB without deduplication.
+     */
+    getRawConnectedDevices(): Promise<AndroidDevice[]>;
+    /**
+     * Retrieves a list of currently connected Android devices.
+     * By default, deduplicates multiple transport channels for the same physical phone (prioritizing USB > Wi-Fi).
+     * @param options.deduplicate Set to false to return raw unfiltered endpoints.
      * @returns A promise resolving to an array of AndroidDevice objects.
      */
-    getConnectedDevices(): Promise<AndroidDevice[]>;
+    getConnectedDevices(options?: {
+        deduplicate?: boolean;
+    }): Promise<AndroidDevice[]>;
+    /**
+     * Helper utility to deduplicate a list of AndroidDevice items.
+     */
+    deduplicateDevices(devices: AndroidDevice[]): AndroidDevice[];
     /**
      * Wakes up the device screen and attempts to dismiss the keyguard.
      * @param serial Optional target device serial.
@@ -406,6 +431,7 @@ export declare class AndroidDriver {
     }, localDestPath: string, serial?: string): Promise<string>;
     /**
      * Checks if the virtual software keyboard (IME) is currently active and visible on screen.
+     * Uses fast shell grep filtering across Android IME & Window properties with resilient fallbacks.
      * @param serial Optional target device serial.
      * @returns Promise resolving to true if virtual keyboard is displayed.
      */

package/dist/lib/ci.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @file ci.ts
+ * @description One-Command CI/CD Workflow Scaffolder for PromptTest (CI-01).
+ * Generates automated regression workflows for GitHub Actions (using reactivecircus/android-emulator-runner)
+ * and GitLab CI with headless emulator virtualization and artifact reporting.
+ */
+export type CiProvider = 'github-actions' | 'gitlab-ci';
+export type CiTrigger = 'push' | 'pull_request' | 'schedule';
+export type CiTarget = 'specs' | 'explore';
+export interface CiWorkflowOptions {
+    /** Target CI provider platform */
+    provider?: CiProvider;
+    /** Trigger events to invoke the pipeline */
+    triggers?: CiTrigger[];
+    /** Execution mode: running specs vs autonomous exploration */
+    target?: CiTarget;
+    /** Spec file or glob pattern to execute */
+    specPattern?: string;
+    /** Target Android package name (required for explore target) */
+    packageName?: string;
+    /** Node.js runtime version to configure */
+    nodeVersion?: number;
+    /** Android API level for the emulator runner */
+    apiLevel?: number;
+    /** CPU architecture for the emulator image */
+    arch?: string;
+}
+export interface CiInitResult {
+    provider: CiProvider;
+    filePath: string;
+    fileName: string;
+    content: string;
+}
+/**
+ * Synthesizes a production-ready GitHub Actions YAML workflow
+ * utilizing headless Android emulator runners and artifact publishing.
+ */
+export declare function generateGithubWorkflow(options?: CiWorkflowOptions): string;
+/**
+ * Synthesizes a GitLab CI YAML configuration.
+ */
+export declare function generateGitlabWorkflow(options?: CiWorkflowOptions): string;
+/**
+ * Scaffolds the CI workflow file directly into the repository directory.
+ */
+export declare function initCi(options?: CiWorkflowOptions & {
+    destDir?: string;
+    customFileName?: string;
+}): Promise<CiInitResult>;

package/dist/lib/jail-guard.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @module jail-guard
+ * @description Zero-Overhead In-Memory App Boundary Guardian for PromptTest.
+ *
+ * Enforces strict package boundary isolation to guarantee that automation
+ * NEVER sends touch, text, or gesture events into third-party personal apps
+ * (e.g. banking apps, email, browsers) or home screen launchers.
+ *
+ * Operates directly on the in-memory parsed hierarchy (UiNode.packageName)
+ * with 0 ms additional ADB overhead in normal operation.
+ */
+import type { UiNode } from './crawler.js';
+import type { AndroidDriver } from './adb.js';
+/**
+ * Registry of known Android OEM launchers and desktop interfaces.
+ */
+export declare const KNOWN_LAUNCHER_PACKAGES: readonly string[];
+/**
+ * Registry of allowed Android system overlay and framework packages
+ * (keyboards, permission dialogs, autofill, package installer).
+ */
+export declare const KNOWN_SYSTEM_PACKAGES: readonly string[];
+/**
+ * Checks if a given package name corresponds to a known launcher or desktop interface.
+ */
+export declare function isLauncherPackage(pkg: string): boolean;
+/**
+ * Checks if a given package name corresponds to an allowed Android system overlay.
+ */
+export declare function isAllowedSystemPackage(pkg: string): boolean;
+/**
+ * Determines whether a specific node's package belongs to the target app under test
+ * or an allowed system overlay (keyboard, permission prompt, system UI).
+ *
+ * @param nodePackage - The package name of the UI node being interacted with.
+ * @param targetPackage - The target application package under test (if specified).
+ */
+export declare function isTargetOrAllowedSystem(nodePackage?: string, targetPackage?: string): boolean;
+/**
+ * Extracts the primary / foreground package from a flattened list of UiNodes.
+ * Evaluates non-system, interactive nodes first, then falls back to the root node.
+ */
+export declare function detectScreenPackage(nodes: UiNode[]): string | null;
+/**
+ * Guards the app boundary: If an escape is detected (screen belongs to a launcher or foreign app),
+ * it blocks further actions, prevents unsafe back-presses on launchers, and brings the target app
+ * back to the foreground.
+ *
+ * @param nodes - In-memory UI nodes from current hierarchy dump.
+ * @param targetPackage - The expected target application package.
+ * @param driver - Android driver instance for containment recovery.
+ * @param serial - Optional target device serial.
+ * @returns Details on whether an escape occurred and whether recovery succeeded.
+ */
+export declare function guardAppBoundary(nodes: UiNode[], targetPackage: string, driver: AndroidDriver, serial?: string): Promise<{
+    escaped: boolean;
+    recovered: boolean;
+    currentPackage: string | null;
+}>;

package/dist/lib/license.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @module license
+ * @description
+ * Viral Report Attribution & Offline Pro Licensing (LC-01).
+ * Cryptographically validates offline license keys, stores activation state,
+ * and controls white-label report formatting.
+ */
+export interface LicensePayload {
+    tier: 'free' | 'pro' | 'enterprise';
+    holder: string;
+    issuedAt: number;
+    expiresAt: number;
+    whiteLabel: boolean;
+    features: string[];
+}
+export interface LicenseInfo {
+    active: boolean;
+    tier: 'free' | 'pro' | 'enterprise';
+    holder?: string;
+    expiresAt?: string;
+    whiteLabel: boolean;
+    features: string[];
+}
+/**
+ * Generates a signed license key string for testing or license distribution.
+ */
+export declare function generateLicenseKey(payload: LicensePayload, secret?: string): string;
+/**
+ * Cryptographically verifies an offline license key string.
+ */
+export declare function verifyLicenseKey(key: string, secret?: string): {
+    valid: boolean;
+    payload?: LicensePayload;
+    error?: string;
+};
+/**
+ * Activates and persists a valid license key locally.
+ */
+export declare function activateLicense(key: string, secret?: string): {
+    success: boolean;
+    message: string;
+    payload?: LicensePayload;
+};
+/**
+ * Retrieves current active license state.
+ */
+export declare function getLicenseInfo(secret?: string): LicenseInfo;
+/**
+ * Removes active license key and reverts to free tier.
+ */
+export declare function deactivateLicense(): boolean;

package/dist/lib/profiler.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @module profiler
+ * @description
+ * Real-Time Mobile Performance & FPS Profiler (PF-01).
+ * Samples `dumpsys gfxinfo <pkg>` and `dumpsys meminfo <pkg>` during test execution,
+ * computes frame rendering statistics, jank percentages, and memory growth.
+ */
+import { AndroidDriver } from './adb.js';
+export interface FrameStats {
+    totalFrames: number;
+    jankyFrames: number;
+    jankPercentage: number;
+    p50Ms?: number;
+    p90Ms?: number;
+    p95Ms?: number;
+    p99Ms?: number;
+    missedVsync?: number;
+    slowUiThread?: number;
+}
+export interface MemorySample {
+    timestamp: number;
+    stepIndex?: number;
+    stepName?: string;
+    totalPssKb: number;
+    nativeHeapKb?: number;
+    javaHeapKb?: number;
+}
+export interface PerformanceReport {
+    packageName: string;
+    durationMs: number;
+    fpsCompliance: 'PASS' | 'WARN' | 'FAIL';
+    frames: FrameStats;
+    memory: {
+        startPssKb: number;
+        peakPssKb: number;
+        endPssKb: number;
+        deltaPssKb: number;
+        samples: MemorySample[];
+    };
+}
+/**
+ * Parses dumpsys gfxinfo stdout to extract frame counts, jank percentage, and percentile latencies.
+ */
+export declare function parseGfxInfo(stdout: string): FrameStats;
+/**
+ * Parses dumpsys meminfo stdout to extract Total PSS, Native Heap, and Java Heap values in KB.
+ */
+export declare function parseMemInfo(stdout: string): {
+    totalPssKb: number;
+    nativeHeapKb?: number;
+    javaHeapKb?: number;
+};
+/**
+ * PerformanceProfiler tracks real-time frame times, jank metrics, and memory growth.
+ */
+export declare class PerformanceProfiler {
+    private driver;
+    private serial?;
+    private packageName;
+    private startTime;
+    private memorySamples;
+    constructor(driver?: AndroidDriver, serial?: string);
+    /**
+     * Starts tracking performance for the target package.
+     */
+    start(packageName: string): Promise<void>;
+    /**
+     * Captures a discrete memory sample at a step transition.
+     */
+    sample(stepIndex: number, stepName: string): Promise<void>;
+    /**
+     * Finalizes tracking and returns the performance report.
+     */
+    stop(): Promise<PerformanceReport>;
+}

package/dist/lib/prompt-runner.d.ts

@@ -19,6 +19,7 @@ export declare class PromptRunner {
     private lastHierarchy;
     private screenDimensions;
     private navBarHeight;
+    private targetPackage;
     /**
      * Initializes a new instance of the PromptRunner.
      * Uses dependency injection for core services, defaulting to singletons if omitted.

package/dist/lib/quiescence.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module quiescence
+ * @description Dynamic Screen Quiescence & Idling Sentinel for PromptTest.
+ *
+ * Implements self-synchronizing stability detection inspired by Playwright's networkidle
+ * and Android Espresso's IdlingResource. Replaces fragile static timers with dual-sample
+ * layout stabilization and active in-flight loading sentinel checks.
+ */
+import type { UiNode } from './crawler.js';
+import type { ExecutionContext } from './step-handlers.js';
+export interface QuiescenceResult {
+    /** Whether the screen reached verified stability before the timeout */
+    settled: boolean;
+    /** Milliseconds elapsed during stabilization */
+    durationMs: number;
+    /** Final structural hash of the quiescent screen */
+    finalHash: string;
+    /** Flattened UI nodes of the quiescent screen */
+    flat: UiNode[];
+}
+/**
+ * Inspects a flattened UI hierarchy to detect active in-flight network spinners,
+ * shimmers, progress bars, or server-waiting indicators.
+ *
+ * @param nodes - Flattened array of UiNodes
+ * @returns Status indicating whether loading is in progress and why.
+ */
+export declare function isLoadingInProgress(nodes: UiNode[]): {
+    loading: boolean;
+    reason?: string;
+};
+/**
+ * Dynamically waits until the application screen achieves 100% quiescence:
+ * 1. All active loading indicators and spinners have vanished.
+ * 2. Two consecutive UI hierarchy snapshots yield matching structural hashes.
+ *
+ * Exits immediately once settled, saving seconds on fast devices while providing
+ * dynamic patience for slow network requests or cloud emulators.
+ *
+ * @param ctx - Execution context providing driver and hierarchy access.
+ * @param timeoutMs - Maximum wait ceiling (defaults to 4500ms).
+ * @param sampleIntervalMs - Interval between stability probe samples (defaults to 150ms).
+ */
+export declare function waitForQuiescence(ctx: ExecutionContext, timeoutMs?: number, sampleIntervalMs?: number): Promise<QuiescenceResult>;

package/dist/lib/reporter.d.ts

@@ -7,6 +7,7 @@
  * JUnit XML. It plays a critical role in providing observability and
  * traceability for autonomous test executions.
  */
+import type { PerformanceReport } from './profiler.js';
 /**
  * Represents a single executed step or action during the test run.
  */
@@ -64,6 +65,14 @@ export interface QaReportData {
     errorsDetected: string[];
     /** Optional relative path to screen recording video (MP4). */
     videoPath?: string;
+    /** Optional performance profiler metrics (PF-01). */
+    performanceMetrics?: PerformanceReport;
+    /** Details of any locators auto-healed during the test run */
+    healsApplied?: Array<{
+        original: string;
+        healed: string;
+        stepNumber: number;
+    }>;
     /** The chronological list of all audit steps executed. */
     steps: AuditStep[];
 }
@@ -148,10 +157,15 @@ export declare class QaReporter implements Reporter {
     private formats;
     private videoPath?;
     private embedScreenshots;
+    private performanceMetrics?;
     private screenshotBuffers;
     private stepListeners;
     private completeListeners;
     private errorListeners;
+    /**
+     * Sets the performance metrics collected by the profiler.
+     */
+    setPerformanceMetrics(metrics: PerformanceReport): void;
     /**
      * Constructs a new QaReporter.
      *

package/dist/lib/runner-utils.d.ts

@@ -7,6 +7,7 @@
  * and diagnostic error generation.
  */
 import { UiNode } from './crawler.js';
+import { AndroidDriver } from './adb.js';
 import { MemoryEngine } from './memory.js';
 import type { QaReportData, Reporter, ReportFormat } from './reporter.js';
 /**
@@ -73,6 +74,8 @@ export interface RunOptions {
     tags?: string;
     /** Emit machine-readable JSON execution summary to stdout. */
     json?: boolean;
+    /** Real-time mobile performance & FPS profiler (PF-01). */
+    profile?: boolean;
 }
 /**
  * Represents a single parsed action step in a plain-English test spec.
@@ -149,6 +152,8 @@ export interface PromptStep {
     emailBodyContains?: string;
     /** Healed locator provenance (original target string) */
     healedFrom?: string;
+    /** Healed replacement string chosen by self-healing */
+    healedTo?: string;
 }
 /**
  * Recursively expands `INCLUDE '<path>'` directives within a spec file.
@@ -288,3 +293,24 @@ export declare function createSyntheticReport(packageName: string, deviceId: str
  * @returns Sanitized or masked string.
  */
 export declare function maskSensitiveValue(value: string, target?: string): string;
+export interface FailureTriageParams {
+    outputDir: string;
+    specName: string;
+    currentSpecName: string;
+    stepNum: number;
+    step: PromptStep;
+    error: Error;
+    stepStartTime: number;
+    startTime: number;
+    errorShot?: Buffer;
+    lastHierarchy?: {
+        xml?: string;
+        flat?: UiNode[];
+    } | null;
+    driver: AndroidDriver;
+    serial?: string;
+}
+/**
+ * Assembles failure triage folder, logs, hierarchy XML, match scores, and a ZIP archive.
+ */
+export declare function createFailureTriageBundle(params: FailureTriageParams): Promise<string | undefined>;

package/dist/lib/scaffold.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @module scaffold
+ * @description
+ * Inspects an active Android screen (or raw XML hierarchy) and synthesizes
+ * a starter plain-English test spec (.txt) containing Launch, Wait, form Type,
+ * button Tap, and element Verify steps.
+ */
+import { AndroidDriver } from './adb.js';
+import { UiNode } from './crawler.js';
+export interface ScaffoldOptions {
+    /** Target package to scaffold. Defaults to active foreground app */
+    packageName?: string;
+    /** Specific device serial to connect to */
+    deviceSerial?: string;
+    /** Explicit output path for the generated spec. Defaults to specs/<pkg>_scaffold.txt */
+    outputPath?: string;
+    /** Driver instance for dependency injection */
+    driver?: AndroidDriver;
+    /** Whether to explore interconnected screens and generate a multi-screen journey spec */
+    journey?: boolean;
+}
+export interface ScaffoldResult {
+    packageName: string;
+    specContent: string;
+    specPath?: string;
+    stepsCount: number;
+    inputCount: number;
+    buttonCount: number;
+}
+/**
+ * Sanitizes node labels by stripping Private Use Area (PUA) icon font glyphs,
+ * special/non-printable unicode codepoints, and leading/trailing punctuation.
+ */
+export declare function sanitizeNodeLabel(label: string): string;
+/**
+ * Derives a human-readable clean label from a UiNode.
+ */
+export declare function getNodeLabel(node: UiNode): string;
+/**
+ * Synthesizes a valid PromptTest specification from a flat list of UiNodes.
+ */
+export declare function scaffoldSpecFromNodes(nodes: UiNode[], packageName?: string): string;
+/**
+ * Validates that every generated step in a spec string parses cleanly with the PromptTest DSL.
+ */
+export declare function validateScaffoldedSpec(specContent: string): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Connects to the device, retrieves screen hierarchy, and writes a scaffolded spec file.
+ */
+export declare function scaffoldSpec(options?: ScaffoldOptions): Promise<ScaffoldResult>;

package/dist/lib/step-handlers.d.ts

@@ -21,6 +21,8 @@ import { PromptStep } from './prompt-runner.js';
  * It encapsulates the driver instance, state cache, and common UI interaction logic.
  */
 export interface ExecutionContext {
+    /** Target application package name under test (used for jail guard containment). */
+    targetPackage?: string;
     /** The ADB-based Android UI driver used to interact with the device. */
     driver: AndroidDriver;
     /** Memory engine used to record and learn resilient locators over time. */

package/docs/ARCHITECTURE.md

@@ -6,7 +6,7 @@ PromptTest is a zero-code, AI-assisted Android test automation and visual QA fra
 
 ## 1. High-Level Architecture Overview
 
-PromptTest operates on a modular layered architecture where test scripts written in natural language or AST-driven directives are compiled, bound to live or synthetic data, executed against connected devices via an isolated locking layer, and reported with visual diffs and interactive HTML reports.
+PromptTest operates on a modular layered architecture where test scripts written in natural language or AST-driven directives are compiled, bound to live or synthetic data, executed against connected devices via an isolated locking layer, and reported with visual diffs and interactive HTML reports. Current release boundaries are tracked in [PRODUCT_STATUS.md](PRODUCT_STATUS.md).
 
 ```
 ┌───────────────────────────────────────────────────────────┐
@@ -35,14 +35,14 @@ PromptTest operates on a modular layered architecture where test scripts written
        │                      │                      │
 ┌──────▼──────────────────────▼──────────────────────▼──────┐
 │              Visual Testing & Diagnostics                 │
-│          lib/baseline.ts (SSIM / Perceptual Diff)         │
+│          lib/baseline.ts (pixelmatch / PNG Diff)          │
 │          lib/explorer.ts (Autonomous Crawler)             │
 └─────────────────────────────┬─────────────────────────────┘
                               │
 ┌─────────────────────────────▼─────────────────────────────┐
 │                 Reporting & Observability                 │
 │       lib/reporter.ts (HTML, JSON, JUnit XML, Markdown)   │
-│       lib/live-server.ts (SSE / WebSocket Live Dash)      │
+│       lib/live-server.ts (HTTP / SSE Live Monitor)        │
 └───────────────────────────────────────────────────────────┘
 ```
 
@@ -100,7 +100,7 @@ Instead of an unwieldy switch-case statement, execution is delegated to decouple
 
 ### 2.6 Visual Baselines & Computer Vision (`lib/baseline.ts`, `lib/explorer.ts`)
 
-- Pixel-by-pixel perceptual diffing and Structural Similarity Index Measure (SSIM) algorithms.
+- Pixel-level image diffing using `pixelmatch` and PNG decoding via `pngjs`.
 - Configurable failure thresholds (e.g. `diffThreshold: 0.02` for 2% variance).
 - Automatic bounding box masking for dynamic regions (e.g. status bar clocks, live feeds) to eliminate false positives in visual regression testing.