@xopcai/xopc 0.0.412 → 0.0.414

package/dist/src/phone/cloud-scrcpy.js

@@ -0,0 +1,123 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { SCRCPY_VERSION } from "../runtime-tools/phone-dependency-catalog.js";
+import { readScrcpyServer } from "./scrcpy-assets.js";
+import { ScrcpyProvider, ScrcpyVideoParser } from "./scrcpy.js";
+import { CloudAdbConnection } from "./cloud-adb.js";
+import { randomBytes } from "node:crypto";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { ReadableStream } from "@yume-chan/stream-extra";
+//#region src/phone/cloud-scrcpy.ts
+init_contracts();
+/** Dedicated authenticated ADB transport: no host ADB key, server or port forwarding. */
+var CloudScrcpyProvider = class extends ScrcpyProvider {
+	connection;
+	process;
+	video;
+	control;
+	writer;
+	remote = "";
+	scid = "";
+	constructor(endpoint, key, onFailure, connect = (address, credential) => new CloudAdbConnection(address, credential)) {
+		super(onFailure);
+		this.endpoint = endpoint;
+		this.connection = connect(endpoint, key);
+	}
+	foreground(signal) {
+		return this.connection.driver().foreground(this.endpoint, signal);
+	}
+	async startTransport() {
+		const timer = setTimeout(() => this.connection.close(), 2e4);
+		try {
+			const binary = await readScrcpyServer();
+			const adb = await this.connection.client();
+			if (this.closing) throw new Error("Video closed");
+			this.scid = (randomBytes(4).readUInt32BE() & 2147483647).toString(16);
+			const socketName = `scrcpy_${this.scid.padStart(8, "0")}`;
+			this.remote = `/data/local/tmp/xopc-${socketName}.jar`;
+			const sync = await adb.sync();
+			try {
+				await sync.write({
+					filename: this.remote,
+					permission: 384,
+					file: new ReadableStream({ start(controller) {
+						controller.enqueue(binary);
+						controller.close();
+					} })
+				});
+			} finally {
+				await sync.dispose();
+			}
+			if (this.closing) throw new Error("Video closed");
+			this.process = await adb.createSocket(`exec:CLASSPATH=${this.remote} app_process / com.genymobile.scrcpy.Server ${SCRCPY_VERSION} scid=${this.scid} tunnel_forward=true audio=false control=true cleanup=false max_size=960 max_fps=30 video_bit_rate=2000000 video_codec=h264 video_codec_options=i-frame-interval=1 send_dummy_byte=false send_device_meta=false send_codec_meta=true send_frame_meta=true clipboard_autosync=false`);
+			this.drain(this.process);
+			for (let attempt = 0; attempt < 60; attempt++) {
+				if (this.closing) throw new Error("Video closed");
+				try {
+					this.video = await adb.createSocket(`localabstract:${socketName}`);
+					break;
+				} catch {
+					await setTimeout$1(50);
+				}
+			}
+			if (!this.video) throw new Error("Scrcpy connection timed out");
+			this.control = await adb.createSocket(`localabstract:${socketName}`);
+			this.writer = this.control.writable.getWriter();
+			this.drain(this.control);
+			this.readVideo(this.video);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async drain(socket) {
+		try {
+			for await (const _chunk of socket.readable);
+		} catch {}
+		if (!this.closing) this.fail();
+	}
+	async readVideo(socket) {
+		const parser = new ScrcpyVideoParser();
+		try {
+			for await (const chunk of socket.readable) parser.push(Buffer.from(chunk), (packet) => this.packet(packet));
+		} catch {}
+		if (!this.closing) this.fail();
+	}
+	async write(buffer) {
+		if (!this.writer) throw new PhoneError("PHONE_INPUT_DISCONNECTED", "Cloud phone input channel unavailable");
+		const timer = setTimeout(() => this.connection.close(), 2e3);
+		try {
+			await this.writer.write(buffer);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async cleanup() {
+		try {
+			await this.revoke().catch(() => {});
+			this.writer?.releaseLock();
+			this.writer = void 0;
+			await Promise.allSettled([
+				this.video?.close(),
+				this.control?.close(),
+				this.process?.close()
+			]);
+			if (this.scid) {
+				const command = (...args) => this.connection.command("", [
+					"-s",
+					this.endpoint,
+					"shell",
+					...args
+				], void 0, 3e3);
+				const processes = await command("ps", "-A", "-o", "PID,ARGS").catch(() => Buffer.alloc(0));
+				for (const line of processes.toString().split("\n")) {
+					const pid = /^\s*(\d+)\s+/.exec(line)?.[1];
+					if (pid && line.includes("com.genymobile.scrcpy.Server ") && new RegExp(`(?:^|\\s)scid=${this.scid}(?:\\s|$)`).test(line)) await command("kill", "-TERM", pid).catch(() => {});
+				}
+				if (this.remote) await command("rm", "-f", this.remote).catch(() => {});
+			}
+		} finally {
+			this.connection.dispose();
+		}
+	}
+};
+//#endregion
+export { CloudScrcpyProvider };

package/dist/src/phone/contracts.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+export declare const PhoneProfileSchema: z.ZodEnum<{
+    "autoglm-phone-v1": "autoglm-phone-v1";
+    "structured-phone-v1": "structured-phone-v1";
+}>;
+export declare const PhoneModelMetadataSchema: z.ZodObject<{
+    profile: z.ZodEnum<{
+        "autoglm-phone-v1": "autoglm-phone-v1";
+        "structured-phone-v1": "structured-phone-v1";
+    }>;
+}, z.core.$strict>;
+export declare const MOCK_PHONE_MODEL = "phone-mock/settings-about";
+export declare const MOCK_PHONE_GOAL = "Open Android Settings and inspect About phone";
+export declare const PhoneConfigSchema: z.ZodPrefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    adbPath: z.ZodOptional<z.ZodString>;
+    maxActionsPerSession: z.ZodDefault<z.ZodNumber>;
+    maxModelRequests: z.ZodDefault<z.ZodNumber>;
+    maxOperationDurationMs: z.ZodDefault<z.ZodNumber>;
+    maxSessionDurationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>>;
+export type PhoneConfig = z.infer<typeof PhoneConfigSchema>;
+export declare const PhoneDeviceSchema: z.ZodObject<{
+    id: z.ZodString;
+    serial: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    appAccess: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        selected: "selected";
+    }>>;
+    allowedApps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    connection: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"aliyun-adb">;
+        endpoint: z.ZodString;
+        credentialId: z.ZodString;
+    }, z.core.$strict>>;
+    createdAt: z.ZodNumber;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+export type PhoneDevice = z.infer<typeof PhoneDeviceSchema>;
+export type PhoneApplication = {
+    packageName: string;
+    label: string;
+};
+export type DiscoveredPhone = {
+    serial: string;
+    state: string;
+    name: string;
+    emulator: boolean;
+};
+export declare const PhoneActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"launch">;
+    package: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tap">;
+    point: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"doubleTap">;
+    point: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"longPress">;
+    point: z.ZodArray<z.ZodNumber>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"swipe">;
+    start: z.ZodArray<z.ZodNumber>;
+    end: z.ZodArray<z.ZodNumber>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"typeText">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodEnum<{
+        home: "home";
+        back: "back";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"wait">;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>], "type">;
+export type PhoneAction = z.infer<typeof PhoneActionSchema>;
+export declare const PhoneDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"action">;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"launch">;
+        package: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tap">;
+        point: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"doubleTap">;
+        point: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"longPress">;
+        point: z.ZodArray<z.ZodNumber>;
+        durationMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"swipe">;
+        start: z.ZodArray<z.ZodNumber>;
+        end: z.ZodArray<z.ZodNumber>;
+        durationMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"typeText">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodEnum<{
+            home: "home";
+            back: "back";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"wait">;
+        durationMs: z.ZodNumber;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"complete">;
+    summary: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"needsUser">;
+    reason: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type PhoneDecision = z.infer<typeof PhoneDecisionSchema>;
+export type PhoneElement = {
+    text: string;
+    description: string;
+    resourceId: string;
+    clickable: boolean;
+    focused: boolean;
+    password: boolean;
+    editable?: boolean;
+    bounds: [number, number, number, number];
+};
+export type PhoneObservation = {
+    frameId: string;
+    capturedAt: number;
+    width: number;
+    height: number;
+    rotation: number;
+    package: string;
+    frame: Buffer;
+    elements: PhoneElement[];
+};
+export declare const PhoneInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"discover">;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"open">;
+    deviceId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        observe: "observe";
+        control: "control";
+    }>;
+    appPackage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"observe">;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodEnum<{
+        run: "run";
+        step: "step";
+    }>;
+    goal: z.ZodString;
+    scenario: z.ZodOptional<z.ZodLiteral<"settings-about">>;
+    expectText: z.ZodOptional<z.ZodString>;
+    maxActions: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodEnum<{
+        cancel: "cancel";
+        status: "status";
+        close: "close";
+        pause: "pause";
+        resume: "resume";
+    }>;
+}, z.core.$strict>], "op">;
+export type PhoneInput = z.infer<typeof PhoneInputSchema>;
+export type PhoneStatus = 'ready' | 'running' | 'paused' | 'needs_user' | 'completed' | 'cancelled' | 'closed' | 'failed' | 'outcome_unknown';
+export type PhoneReport = {
+    sessionId: string;
+    deviceId: string;
+    deviceName: string;
+    owner: string;
+    agentId: string;
+    modelRef: string;
+    mock: boolean;
+    mode: 'observe' | 'control';
+    status: PhoneStatus;
+    actions: number;
+    humanActions?: number;
+    modelRequests: number;
+    createdAt: number;
+    updatedAt: number;
+    verified: boolean;
+    verificationLevel: 'none' | 'ui';
+    stopReason?: string;
+    errorCode?: string;
+    facts?: string[];
+    foregroundApp?: string;
+    message?: string;
+    steps: Array<{
+        action: PhoneAction['type'];
+        at: number;
+        dispatch: 'completed' | 'unknown';
+        actor?: 'agent' | 'human';
+    }>;
+    controlOwner?: 'agent' | 'human' | 'none';
+    controlEpoch?: number;
+    handoff?: 'idle' | 'acquiring' | 'returning';
+    currentAction?: PhoneAction['type'];
+};
+export declare class PhoneError extends Error {
+    readonly code: string;
+    readonly status: 400 | 403 | 404 | 409 | 500 | 502;
+    constructor(code: string, message: string, status?: 400 | 403 | 404 | 409 | 500 | 502);
+}

package/dist/src/phone/contracts.js

@@ -0,0 +1,116 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region src/phone/contracts.ts
+var PhoneProfileSchema, PhoneModelMetadataSchema, MOCK_PHONE_MODEL, MOCK_PHONE_GOAL, PhoneConfigSchema, PhoneDeviceSchema, Point, PhoneActionSchema, PhoneDecisionSchema, PhoneInputSchema, PhoneError;
+var init_contracts = __esmMin((() => {
+	PhoneProfileSchema = z.enum(["autoglm-phone-v1", "structured-phone-v1"]);
+	PhoneModelMetadataSchema = z.object({ profile: PhoneProfileSchema }).strict();
+	MOCK_PHONE_MODEL = "phone-mock/settings-about";
+	MOCK_PHONE_GOAL = "Open Android Settings and inspect About phone";
+	PhoneConfigSchema = z.object({
+		enabled: z.boolean().default(false),
+		adbPath: z.string().min(1).optional(),
+		maxActionsPerSession: z.number().int().min(1).max(80).default(40),
+		maxModelRequests: z.number().int().min(1).max(120).default(60),
+		maxOperationDurationMs: z.number().int().min(1e3).max(9e5).default(3e5),
+		maxSessionDurationMs: z.number().int().min(1e3).max(9e5).default(9e5)
+	}).strict().prefault({});
+	PhoneDeviceSchema = z.object({
+		id: z.string().uuid(),
+		serial: z.string().min(1).max(200),
+		name: z.string().trim().min(1).max(100),
+		enabled: z.boolean().default(true),
+		appAccess: z.enum(["all", "selected"]).optional(),
+		allowedApps: z.array(z.string().regex(/^[a-zA-Z][\w]*(?:\.[\w]+)+$/)).max(500).default([]),
+		connection: z.object({
+			kind: z.literal("aliyun-adb"),
+			endpoint: z.string().max(200),
+			credentialId: z.string().uuid()
+		}).strict().optional(),
+		createdAt: z.number(),
+		revision: z.number().int().positive()
+	}).strict();
+	Point = z.array(z.number().finite().min(0).max(1e3)).length(2);
+	PhoneActionSchema = z.discriminatedUnion("type", [
+		z.object({
+			type: z.literal("launch"),
+			package: z.string().regex(/^[a-zA-Z][\w]*(?:\.[\w]+)+$/)
+		}).strict(),
+		z.object({
+			type: z.literal("tap"),
+			point: Point
+		}).strict(),
+		z.object({
+			type: z.literal("doubleTap"),
+			point: Point
+		}).strict(),
+		z.object({
+			type: z.literal("longPress"),
+			point: Point,
+			durationMs: z.number().int().min(100).max(3e3).default(800)
+		}).strict(),
+		z.object({
+			type: z.literal("swipe"),
+			start: Point,
+			end: Point,
+			durationMs: z.number().int().min(100).max(2e3).default(500)
+		}).strict(),
+		z.object({
+			type: z.literal("typeText"),
+			text: z.string().min(1).max(4e3)
+		}).strict(),
+		z.object({ type: z.enum(["back", "home"]) }).strict(),
+		z.object({
+			type: z.literal("wait"),
+			durationMs: z.number().int().min(100).max(3e3)
+		}).strict()
+	]);
+	PhoneDecisionSchema = z.discriminatedUnion("kind", [
+		z.object({
+			kind: z.literal("action"),
+			action: PhoneActionSchema
+		}).strict(),
+		z.object({
+			kind: z.literal("complete"),
+			summary: z.string().max(1e3)
+		}).strict(),
+		z.object({
+			kind: z.literal("needsUser"),
+			reason: z.string().max(1e3)
+		}).strict()
+	]);
+	PhoneInputSchema = z.discriminatedUnion("op", [
+		z.object({ op: z.literal("discover") }).strict(),
+		z.object({
+			op: z.literal("open"),
+			deviceId: z.string().uuid().optional(),
+			mode: z.enum(["observe", "control"]),
+			appPackage: z.string().regex(/^[a-zA-Z][\w]*(?:\.[\w]+)+$/).optional()
+		}).strict(),
+		z.object({ op: z.literal("observe") }).strict(),
+		z.object({
+			op: z.enum(["run", "step"]),
+			goal: z.string().trim().min(1).max(2e3),
+			scenario: z.literal("settings-about").optional(),
+			expectText: z.string().min(1).max(200).optional(),
+			maxActions: z.number().int().min(1).max(12).default(6)
+		}).strict(),
+		z.object({ op: z.enum([
+			"status",
+			"pause",
+			"resume",
+			"cancel",
+			"close"
+		]) }).strict()
+	]);
+	PhoneError = class extends Error {
+		constructor(code, message, status = 400) {
+			super(message);
+			this.code = code;
+			this.status = status;
+		}
+	};
+}));
+//#endregion
+init_contracts();
+export { MOCK_PHONE_GOAL, MOCK_PHONE_MODEL, PhoneActionSchema, PhoneConfigSchema, PhoneDecisionSchema, PhoneDeviceSchema, PhoneError, PhoneInputSchema, PhoneModelMetadataSchema, PhoneProfileSchema, init_contracts };

package/dist/src/phone/interactive-session.d.ts

@@ -0,0 +1,34 @@
+import type { PhoneInteractiveProvider, PhonePointer, PhoneVideoPacket } from './live-provider.js';
+/** Shared device source with bounded video gating and ordered, fenced input. */
+export declare class PhoneInteractiveSession {
+    readonly provider: PhoneInteractiveProvider;
+    private checkScreen;
+    private authorize;
+    private onGesture;
+    private viewers;
+    private queue;
+    private pending;
+    private seq;
+    private packets;
+    private bytes;
+    private checkedAt;
+    private allowed;
+    private closed;
+    private timer?;
+    private unsubscribe?;
+    private config?;
+    private started?;
+    private gesture?;
+    private verification?;
+    constructor(provider: PhoneInteractiveProvider, checkScreen: () => Promise<void>, authorize: (client: string, epoch: number) => void, onGesture?: (action: 'tap' | 'longPress' | 'swipe') => void);
+    start(): Promise<void>;
+    private verifyScreen;
+    private poll;
+    subscribe(client: string, packet: (packet: PhoneVideoPacket) => void, fault: (code: string) => void): () => void;
+    input(client: string, input: PhonePointer): Promise<void>;
+    revoke(): Promise<void>;
+    close(): Promise<void>;
+    get viewerCount(): number;
+    verifyGeometry(version: number): boolean;
+    authorizeClient(client: string, epoch: number): void;
+}

package/dist/src/phone/interactive-session.js

@@ -0,0 +1,164 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+//#region src/phone/interactive-session.ts
+init_contracts();
+/** Shared device source with bounded video gating and ordered, fenced input. */
+var PhoneInteractiveSession = class {
+	viewers = /* @__PURE__ */ new Map();
+	queue = Promise.resolve();
+	pending = 0;
+	seq = /* @__PURE__ */ new Map();
+	packets = [];
+	bytes = 0;
+	checkedAt = 0;
+	allowed = false;
+	closed = false;
+	timer;
+	unsubscribe;
+	config;
+	started;
+	gesture;
+	verification;
+	constructor(provider, checkScreen, authorize, onGesture = () => {}) {
+		this.provider = provider;
+		this.checkScreen = checkScreen;
+		this.authorize = authorize;
+		this.onGesture = onGesture;
+	}
+	start() {
+		return this.started ??= (async () => {
+			await this.checkScreen();
+			this.checkedAt = Date.now();
+			this.allowed = true;
+			this.unsubscribe = this.provider.subscribe((packet) => {
+				if (packet.config) this.config = packet;
+				this.packets.push(packet);
+				this.bytes += packet.data.length;
+				if (this.bytes > 2 * 1024 * 1024) {
+					this.packets = [];
+					this.bytes = 0;
+					for (const viewer of this.viewers.values()) viewer.key = false;
+				}
+			});
+			await this.provider.start();
+			this.poll();
+		})();
+	}
+	verifyScreen() {
+		return this.verification ??= this.checkScreen().then(() => {
+			this.checkedAt = Date.now();
+			this.allowed = true;
+		}, (error) => {
+			this.allowed = false;
+			throw error;
+		}).finally(() => {
+			this.verification = void 0;
+		});
+	}
+	async poll() {
+		if (this.closed) return;
+		const packets = this.packets;
+		this.packets = [];
+		this.bytes = 0;
+		try {
+			const wasAllowed = this.allowed;
+			await this.verifyScreen();
+			if (this.closed) return;
+			if (!wasAllowed) this.provider.refresh();
+			for (const packet of packets) for (const viewer of this.viewers.values()) {
+				if (packet.geometry && packet.geometry.version !== this.provider.geometry.version) continue;
+				if (packet.config) {
+					viewer.key = false;
+					viewer.packet(packet);
+				} else if (packet.key || viewer.key) {
+					if (!viewer.key && this.config) viewer.packet(this.config);
+					viewer.key = true;
+					viewer.packet(packet);
+				}
+			}
+		} catch (error) {
+			this.allowed = false;
+			this.packets = [];
+			this.bytes = 0;
+			await this.revoke().catch(() => {});
+			const code = error instanceof PhoneError ? error.code : "PHONE_VIDEO_DISCONNECTED";
+			for (const viewer of this.viewers.values()) {
+				viewer.key = false;
+				viewer.fault(code);
+			}
+		}
+		if (!this.closed) this.timer = setTimeout(() => void this.poll(), 35);
+	}
+	subscribe(client, packet, fault) {
+		if (this.viewers.has(client) || this.viewers.size >= 4) throw new PhoneError("PHONE_VIEW_BUSY", "Phone viewer connection limit reached", 409);
+		this.viewers.set(client, {
+			packet,
+			fault,
+			key: false
+		});
+		this.provider.refresh();
+		return () => {
+			this.viewers.delete(client);
+			this.seq.delete(client);
+		};
+	}
+	input(client, input) {
+		this.authorize(client, input.epoch);
+		if (this.closed || !this.allowed) throw new PhoneError("PHONE_SCREEN_UNVERIFIED", "Wait for an authorized phone frame", 409);
+		if (input.seq <= (this.seq.get(client) ?? 0)) throw new PhoneError("PHONE_INPUT_SEQUENCE", "Stale input sequence", 409);
+		if (this.pending >= 8) throw new PhoneError("PHONE_INPUT_BACKPRESSURE", "Input queue full; release and start a new gesture", 409);
+		this.seq.set(client, input.seq);
+		this.pending++;
+		const work = this.queue.catch(() => {}).then(async () => {
+			this.authorize(client, input.epoch);
+			if (Date.now() - this.checkedAt > 300) await this.verifyScreen();
+			this.authorize(client, input.epoch);
+			if (!this.allowed || this.closed) throw new PhoneError("PHONE_APP_DENIED", "Phone screen is unavailable", 403);
+			await this.provider.pointer(input);
+			if (input.phase === "down") this.gesture = {
+				x: input.x,
+				y: input.y,
+				at: Date.now()
+			};
+			else if (input.phase === "up" || input.phase === "cancel") {
+				const start = this.gesture;
+				this.gesture = void 0;
+				if (start) this.onGesture(Math.hypot(start.x - input.x, start.y - input.y) > 18 ? "swipe" : Date.now() - start.at > 600 ? "longPress" : "tap");
+			}
+		}).finally(() => {
+			this.pending--;
+		});
+		this.queue = work;
+		return work;
+	}
+	async revoke() {
+		const work = this.queue.catch(() => {}).then(async () => {
+			await this.provider.revoke();
+			this.gesture = void 0;
+		});
+		this.queue = work;
+		await work;
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		clearTimeout(this.timer);
+		await this.revoke().catch(() => {});
+		this.unsubscribe?.();
+		for (const viewer of this.viewers.values()) viewer.fault("PHONE_VIDEO_ENDED");
+		this.viewers.clear();
+		this.packets = [];
+		this.config = void 0;
+		await this.provider.close();
+	}
+	get viewerCount() {
+		return this.viewers.size;
+	}
+	verifyGeometry(version) {
+		return this.allowed && Date.now() - this.checkedAt < 300 && version === this.provider.geometry.version;
+	}
+	authorizeClient(client, epoch) {
+		this.authorize(client, epoch);
+	}
+};
+//#endregion
+export { PhoneInteractiveSession };