agent-device 0.7.20 → 0.7.22

package/dist/src/daemon/handlers/install-source.d.ts

@@ -0,0 +1,10 @@
+import { SessionStore } from '../session-store.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+export declare function handleInstallFromSourceCommand(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    sessionStore: SessionStore;
+}): Promise<DaemonResponse>;
+export declare function handleReleaseMaterializedPathsCommand(params: {
+    req: DaemonRequest;
+}): Promise<DaemonResponse>;

package/dist/src/daemon/handlers/interaction.d.ts

@@ -0,0 +1,14 @@
+import { dispatchCommand, type CommandFlags } from '../../core/dispatch.ts';
+import type { DaemonCommandContext } from '../context.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+import { SessionStore } from '../session-store.ts';
+type ContextFromFlags = (flags: CommandFlags | undefined, appBundleId?: string, traceLogPath?: string) => DaemonCommandContext;
+export declare function handleInteractionCommands(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    sessionStore: SessionStore;
+    contextFromFlags: ContextFromFlags;
+    dispatch?: typeof dispatchCommand;
+}): Promise<DaemonResponse | null>;
+export declare function unsupportedRefSnapshotFlags(flags: CommandFlags | undefined): string[];
+export {};

package/dist/src/daemon/handlers/lease.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+import type { LeaseRegistry } from '../lease-registry.ts';
+type LeaseHandlerArgs = {
+    req: DaemonRequest;
+    leaseRegistry: LeaseRegistry;
+};
+export declare function handleLeaseCommands(args: LeaseHandlerArgs): Promise<DaemonResponse | null>;
+export {};

package/dist/src/daemon/handlers/parse-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const POLL_INTERVAL_MS = 300;
+export declare const DEFAULT_TIMEOUT_MS = 10000;
+export declare function parseTimeout(value: string | undefined): number | null;

package/dist/src/daemon/handlers/record-trace.d.ts

@@ -0,0 +1,15 @@
+import { runCmd, runCmdBackground } from '../../utils/exec.ts';
+import { runIosRunnerCommand } from '../../platforms/ios/runner-client.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+import { SessionStore } from '../session-store.ts';
+export declare function handleRecordTraceCommands(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    sessionStore: SessionStore;
+    logPath?: string;
+    deps?: {
+        runCmd: typeof runCmd;
+        runCmdBackground: typeof runCmdBackground;
+        runIosRunnerCommand: typeof runIosRunnerCommand;
+    };
+}): Promise<DaemonResponse | null>;

package/dist/src/daemon/handlers/session-replay-heal.d.ts

@@ -0,0 +1,8 @@
+import type { SessionAction, SessionState } from '../types.ts';
+import type { SnapshotState } from '../../utils/snapshot.ts';
+export declare function parseSelectorWaitPositionals(positionals: string[]): {
+    selectorExpression: string | null;
+    selectorTimeout: string | null;
+};
+export declare function collectReplaySelectorCandidates(action: SessionAction): string[];
+export declare function healNumericGetTextDrift(action: SessionAction, snapshot: SnapshotState, session: SessionState): SessionAction | null;

package/dist/src/daemon/handlers/session-replay-script.d.ts

@@ -0,0 +1,3 @@
+import type { SessionAction, SessionState } from '../types.ts';
+export declare function parseReplayScript(script: string): SessionAction[];
+export declare function writeReplayScript(filePath: string, actions: SessionAction[], session?: SessionState): void;

package/dist/src/daemon/handlers/session.d.ts

@@ -0,0 +1,67 @@
+import { dispatchCommand, resolveTargetDevice } from '../../core/dispatch.ts';
+import { type DeviceInfo } from '../../utils/device.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+import { SessionStore } from '../session-store.ts';
+import { ensureDeviceReady } from '../device-ready.ts';
+import { stopIosRunnerSession } from '../../platforms/ios/runner-client.ts';
+import { shutdownSimulator } from '../../platforms/ios/simulator.ts';
+import { startAppLog, stopAppLog } from '../app-log.ts';
+import { applyRuntimeHintsToApp, clearRuntimeHintsFromApp } from '../runtime-hints.ts';
+type ReinstallOps = {
+    ios: (device: DeviceInfo, app: string, appPath: string) => Promise<{
+        bundleId: string;
+    }>;
+    android: (device: DeviceInfo, app: string, appPath: string) => Promise<{
+        package: string;
+    }>;
+};
+type AppDeployOps = {
+    ios: (device: DeviceInfo, app: string, appPath: string) => Promise<{
+        bundleId?: string;
+        appName?: string;
+        launchTarget?: string;
+    }>;
+    android: (device: DeviceInfo, app: string, appPath: string) => Promise<{
+        package?: string;
+        appName?: string;
+        launchTarget?: string;
+    }>;
+};
+type InstallOps = AppDeployOps;
+type EnsureAndroidEmulatorBoot = (params: {
+    avdName: string;
+    serial?: string;
+    headless?: boolean;
+}) => Promise<DeviceInfo>;
+declare function settleIosSimulator(device: DeviceInfo, delayMs: number): Promise<void>;
+declare function shutdownAndroidEmulator(device: DeviceInfo): Promise<{
+    success: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function handleSessionCommands(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    logPath: string;
+    sessionStore: SessionStore;
+    invoke: (req: DaemonRequest) => Promise<DaemonResponse>;
+    dispatch?: typeof dispatchCommand;
+    ensureReady?: typeof ensureDeviceReady;
+    resolveTargetDevice?: typeof resolveTargetDevice;
+    installOps?: InstallOps;
+    reinstallOps?: ReinstallOps;
+    stopIosRunner?: typeof stopIosRunnerSession;
+    appLogOps?: {
+        start: typeof startAppLog;
+        stop: typeof stopAppLog;
+    };
+    ensureAndroidEmulatorBoot?: EnsureAndroidEmulatorBoot;
+    resolveAndroidPackageForOpen?: (device: DeviceInfo, openTarget: string | undefined) => Promise<string | undefined>;
+    applyRuntimeHints?: typeof applyRuntimeHintsToApp;
+    clearRuntimeHints?: typeof clearRuntimeHintsFromApp;
+    settleSimulator?: typeof settleIosSimulator;
+    shutdownSimulator?: typeof shutdownSimulator;
+    shutdownAndroidEmulator?: typeof shutdownAndroidEmulator;
+}): Promise<DaemonResponse | null>;
+export {};

package/dist/src/daemon/handlers/snapshot.d.ts

@@ -0,0 +1,32 @@
+import { dispatchCommand } from '../../core/dispatch.ts';
+import { runIosRunnerCommand } from '../../platforms/ios/runner-client.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+import { SessionStore } from '../session-store.ts';
+import { type SelectorChain } from '../selectors.ts';
+export declare function handleSnapshotCommands(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    logPath: string;
+    sessionStore: SessionStore;
+    dispatchSnapshotCommand?: typeof dispatchCommand;
+    runnerCommand?: typeof runIosRunnerCommand;
+}): Promise<DaemonResponse | null>;
+type WaitParsed = {
+    kind: 'sleep';
+    durationMs: number;
+} | {
+    kind: 'ref';
+    rawRef: string;
+    timeoutMs: number | null;
+} | {
+    kind: 'selector';
+    selector: SelectorChain;
+    selectorExpression: string;
+    timeoutMs: number | null;
+} | {
+    kind: 'text';
+    text: string;
+    timeoutMs: number | null;
+};
+export declare function parseWaitArgs(args: string[]): WaitParsed | null;
+export {};

package/dist/src/daemon/http-server.d.ts

@@ -0,0 +1,26 @@
+import http, { type IncomingHttpHeaders } from 'node:http';
+import type { DaemonRequest, DaemonResponse } from './types.ts';
+type JsonRpcRequest = {
+    jsonrpc?: string;
+    id?: string | number | null;
+    method?: string;
+    params?: unknown;
+};
+export type HttpAuthHookContext = {
+    headers: IncomingHttpHeaders;
+    rpcRequest: JsonRpcRequest;
+    daemonRequest: DaemonRequest;
+};
+export type HttpAuthHookResult = boolean | void | {
+    ok?: boolean;
+    tenantId?: string;
+    code?: string;
+    message?: string;
+    details?: Record<string, unknown>;
+};
+export type HttpAuthHook = (context: HttpAuthHookContext) => Promise<HttpAuthHookResult> | HttpAuthHookResult;
+export declare function createDaemonHttpServer(options: {
+    handleRequest: (req: DaemonRequest) => Promise<DaemonResponse>;
+    token?: string;
+}): Promise<http.Server>;
+export {};

package/dist/src/daemon/is-predicates.d.ts

@@ -0,0 +1,14 @@
+import type { SnapshotState } from '../utils/snapshot.ts';
+type IsPredicate = 'visible' | 'hidden' | 'exists' | 'editable' | 'selected' | 'text';
+export declare function isSupportedPredicate(input: string): input is IsPredicate;
+export declare function evaluateIsPredicate(params: {
+    predicate: Exclude<IsPredicate, 'exists'>;
+    node: SnapshotState['nodes'][number];
+    expectedText?: string;
+    platform: 'ios' | 'android';
+}): {
+    pass: boolean;
+    actualText: string;
+    details: string;
+};
+export {};

package/dist/src/daemon/lease-context.d.ts

@@ -0,0 +1,9 @@
+import type { DaemonRequest } from './types.ts';
+export type LeaseScope = {
+    tenantId?: string;
+    runId?: string;
+    leaseId?: string;
+    leaseTtlMs?: number;
+    leaseBackend?: 'ios-simulator';
+};
+export declare function resolveLeaseScope(req: Pick<DaemonRequest, 'flags' | 'meta'>): LeaseScope;

package/dist/src/daemon/lease-registry.d.ts

@@ -0,0 +1,63 @@
+export type LeaseBackend = 'ios-simulator';
+export type SimulatorLease = {
+    leaseId: string;
+    tenantId: string;
+    runId: string;
+    backend: LeaseBackend;
+    createdAt: number;
+    heartbeatAt: number;
+    expiresAt: number;
+};
+export type LeaseRegistryOptions = {
+    maxActiveSimulatorLeases?: number;
+    defaultLeaseTtlMs?: number;
+    minLeaseTtlMs?: number;
+    maxLeaseTtlMs?: number;
+    now?: () => number;
+};
+export type AllocateLeaseRequest = {
+    tenantId: string;
+    runId: string;
+    backend?: LeaseBackend;
+    ttlMs?: number;
+};
+export type HeartbeatLeaseRequest = {
+    leaseId: string;
+    tenantId?: string;
+    runId?: string;
+    ttlMs?: number;
+};
+export type ReleaseLeaseRequest = {
+    leaseId: string;
+    tenantId?: string;
+    runId?: string;
+};
+export type AdmissionRequest = {
+    tenantId: string | undefined;
+    runId: string | undefined;
+    leaseId: string | undefined;
+    backend?: LeaseBackend;
+};
+export declare class LeaseRegistry {
+    private readonly leases;
+    private readonly runBindings;
+    private readonly maxActiveSimulatorLeases;
+    private readonly defaultLeaseTtlMs;
+    private readonly minLeaseTtlMs;
+    private readonly maxLeaseTtlMs;
+    private readonly now;
+    constructor(options?: LeaseRegistryOptions);
+    allocateLease(request: AllocateLeaseRequest): SimulatorLease;
+    heartbeatLease(request: HeartbeatLeaseRequest): SimulatorLease;
+    releaseLease(request: ReleaseLeaseRequest): {
+        released: boolean;
+    };
+    assertLeaseAdmission(request: AdmissionRequest): void;
+    listActiveLeases(): SimulatorLease[];
+    private cleanupExpiredLeases;
+    private enforceCapacity;
+    private resolveLeaseTtlMs;
+    private refreshLease;
+    private bindingKey;
+    private assertOptionalScopeMatch;
+}

package/dist/src/daemon/materialized-path-registry.d.ts

@@ -0,0 +1,15 @@
+export type RetainedMaterializedPaths = {
+    materializationId: string;
+    installablePath: string;
+    archivePath?: string;
+    expiresAt: string;
+};
+export declare function retainMaterializedPaths(params: {
+    installablePath: string;
+    archivePath?: string;
+    tenantId?: string;
+    sessionName?: string;
+    ttlMs?: number;
+}): Promise<RetainedMaterializedPaths>;
+export declare function cleanupRetainedMaterializedPaths(materializationId: string, tenantId?: string): Promise<void>;
+export declare function cleanupRetainedMaterializedPathsForSession(sessionName: string): Promise<void>;

package/dist/src/daemon/network-log.d.ts

@@ -0,0 +1,32 @@
+type NetworkIncludeMode = 'summary' | 'headers' | 'body' | 'all';
+export type NetworkEntry = {
+    method?: string;
+    url: string;
+    status?: number;
+    timestamp?: string;
+    headers?: string;
+    requestBody?: string;
+    responseBody?: string;
+    raw: string;
+    line: number;
+};
+export type NetworkDump = {
+    path: string;
+    exists: boolean;
+    scannedLines: number;
+    matchedLines: number;
+    entries: NetworkEntry[];
+    include: NetworkIncludeMode;
+    limits: {
+        maxEntries: number;
+        maxPayloadChars: number;
+        maxScanLines: number;
+    };
+};
+export declare function readRecentNetworkTraffic(logPath: string, options?: {
+    maxEntries?: number;
+    include?: NetworkIncludeMode;
+    maxPayloadChars?: number;
+    maxScanLines?: number;
+}): NetworkDump;
+export {};

package/dist/src/daemon/request-cancel.d.ts

@@ -0,0 +1,9 @@
+import { AppError } from '../utils/errors.ts';
+export declare function resolveRequestTrackingId(requestId: string | undefined, fallbackSeed?: unknown): string;
+export declare function registerRequestAbort(requestId: string | undefined): void;
+export declare function markRequestCanceled(requestId: string | undefined): void;
+export declare function clearRequestCanceled(requestId: string | undefined): void;
+export declare function isRequestCanceled(requestId: string | undefined): boolean;
+export declare function getRequestSignal(requestId: string | undefined): AbortSignal | undefined;
+export declare function createRequestCanceledError(): AppError;
+export declare function isRequestCanceledError(error: unknown): boolean;

package/dist/src/daemon/request-router.d.ts

@@ -0,0 +1,17 @@
+import { dispatchCommand } from '../core/dispatch.ts';
+import type { DaemonRequest, DaemonResponse } from './types.ts';
+import { SessionStore } from './session-store.ts';
+import type { LeaseRegistry } from './lease-registry.ts';
+export type RequestRouterDeps = {
+    logPath: string;
+    token: string;
+    sessionStore: SessionStore;
+    leaseRegistry: LeaseRegistry;
+    trackDownloadableArtifact: (opts: {
+        artifactPath: string;
+        tenantId?: string;
+        fileName?: string;
+    }) => string;
+    dispatchCommand?: typeof dispatchCommand;
+};
+export declare function createRequestHandler(deps: RequestRouterDeps): (req: DaemonRequest) => Promise<DaemonResponse>;

package/dist/src/daemon/runtime-hints.d.ts

@@ -0,0 +1,19 @@
+import type { DeviceInfo } from '../utils/device.ts';
+import type { SessionRuntimeHints } from './types.ts';
+type ResolvedRuntimeTransport = {
+    host: string;
+    port: number;
+    scheme: 'http' | 'https';
+};
+export declare function hasRuntimeTransportHints(runtime: SessionRuntimeHints | undefined): boolean;
+export declare function resolveRuntimeTransportHints(runtime: SessionRuntimeHints | undefined): ResolvedRuntimeTransport | undefined;
+export declare function applyRuntimeHintsToApp(params: {
+    device: DeviceInfo;
+    appId?: string;
+    runtime: SessionRuntimeHints | undefined;
+}): Promise<void>;
+export declare function clearRuntimeHintsFromApp(params: {
+    device: DeviceInfo;
+    appId?: string;
+}): Promise<void>;
+export {};

package/dist/src/daemon/script-utils.d.ts

@@ -0,0 +1,15 @@
+import type { SessionAction } from './types.ts';
+export declare function isClickLikeCommand(command: string): command is 'click' | 'press';
+export declare function formatScriptArg(value: string): string;
+export declare function formatScriptArgQuoteIfNeeded(value: string): string;
+export declare function formatScriptActionSummary(action: SessionAction): string;
+export declare function appendScriptSeriesFlags(parts: string[], action: Pick<SessionAction, 'command' | 'flags'>): void;
+export declare function appendRuntimeHintFlags(parts: string[], flags: Pick<SessionAction, 'flags'>['flags']): void;
+export declare function parseReplaySeriesFlags(command: string, args: string[]): {
+    positionals: string[];
+    flags: SessionAction['flags'];
+};
+export declare function parseReplayRuntimeFlags(args: string[]): {
+    positionals: string[];
+    flags: SessionAction['flags'];
+};

package/dist/src/daemon/scroll-planner.d.ts

@@ -0,0 +1,12 @@
+import { type RawSnapshotNode, type Rect } from '../utils/snapshot.ts';
+type ScrollIntoViewPlan = {
+    x: number;
+    startY: number;
+    endY: number;
+    count: number;
+    direction: 'up' | 'down';
+};
+export declare function resolveViewportRect(nodes: RawSnapshotNode[], targetRect: Rect): Rect | null;
+export declare function buildScrollIntoViewPlan(targetRect: Rect, viewportRect: Rect): ScrollIntoViewPlan | null;
+export declare function isRectWithinSafeViewportBand(targetRect: Rect, viewportRect: Rect): boolean;
+export {};

package/dist/src/daemon/selectors.d.ts

@@ -0,0 +1,65 @@
+import type { SnapshotNode, SnapshotState } from '../utils/snapshot.ts';
+type SelectorKey = 'id' | 'role' | 'text' | 'label' | 'value' | 'visible' | 'hidden' | 'editable' | 'selected' | 'enabled' | 'hittable';
+type SelectorTerm = {
+    key: SelectorKey;
+    value: string | boolean;
+};
+type Selector = {
+    raw: string;
+    terms: SelectorTerm[];
+};
+export type SelectorChain = {
+    raw: string;
+    selectors: Selector[];
+};
+type SelectorDiagnostics = {
+    selector: string;
+    matches: number;
+};
+type SelectorResolution = {
+    node: SnapshotNode;
+    selector: Selector;
+    selectorIndex: number;
+    matches: number;
+    diagnostics: SelectorDiagnostics[];
+};
+export declare function parseSelectorChain(expression: string): SelectorChain;
+export declare function tryParseSelectorChain(expression: string): SelectorChain | null;
+export declare function resolveSelectorChain(nodes: SnapshotState['nodes'], chain: SelectorChain, options: {
+    platform: 'ios' | 'android';
+    requireRect?: boolean;
+    requireUnique?: boolean;
+    disambiguateAmbiguous?: boolean;
+}): SelectorResolution | null;
+export declare function findSelectorChainMatch(nodes: SnapshotState['nodes'], chain: SelectorChain, options: {
+    platform: 'ios' | 'android';
+    requireRect?: boolean;
+}): {
+    selectorIndex: number;
+    selector: Selector;
+    matches: number;
+    diagnostics: SelectorDiagnostics[];
+} | null;
+export declare function formatSelectorFailure(chain: SelectorChain, diagnostics: SelectorDiagnostics[], options: {
+    unique?: boolean;
+}): string;
+export declare function isSelectorToken(token: string): boolean;
+export declare function splitSelectorFromArgs(args: string[], options?: {
+    preferTrailingValue?: boolean;
+}): {
+    selectorExpression: string;
+    rest: string[];
+} | null;
+export declare function splitIsSelectorArgs(positionals: string[]): {
+    predicate: string;
+    split: {
+        selectorExpression: string;
+        rest: string[];
+    } | null;
+};
+export declare function isNodeVisible(node: SnapshotNode): boolean;
+export declare function isNodeEditable(node: SnapshotNode, platform: 'ios' | 'android'): boolean;
+export declare function buildSelectorChainForNode(node: SnapshotNode, _platform: 'ios' | 'android', options?: {
+    action?: 'click' | 'fill' | 'get';
+}): string[];
+export {};

package/dist/src/daemon/server-lifecycle.d.ts

@@ -0,0 +1,23 @@
+import { readVersion } from '../utils/version.ts';
+import { readProcessStartTime } from '../utils/process-identity.ts';
+export type DaemonLockInfo = {
+    pid: number;
+    version: string;
+    startedAt: number;
+    processStartTime?: string;
+};
+export declare function resolveDaemonCodeSignature(): string;
+export declare function writeInfo(baseDir: string, infoPath: string, logPath: string, opts: {
+    socketPort?: number;
+    httpPort?: number;
+    token: string;
+    version: string;
+    codeSignature: string;
+    processStartTime: string | undefined;
+}): void;
+export declare function removeInfo(infoPath: string): void;
+export declare function readLockInfo(lockPath: string): DaemonLockInfo | null;
+export declare function acquireDaemonLock(baseDir: string, lockPath: string, lockData: DaemonLockInfo): boolean;
+export declare function releaseDaemonLock(lockPath: string): void;
+export declare function parseIntegerEnv(raw: string | undefined): number | undefined;
+export { readVersion, readProcessStartTime };

package/dist/src/daemon/session-routing.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonRequest } from './types.ts';
+import { SessionStore } from './session-store.ts';
+export declare function resolveEffectiveSessionName(req: DaemonRequest, sessionStore: SessionStore): string;

package/dist/src/daemon/session-selector.d.ts

@@ -0,0 +1,3 @@
+import type { CommandFlags } from '../core/dispatch.ts';
+import type { SessionState } from './types.ts';
+export declare function assertSessionSelectorMatches(session: SessionState, flags?: CommandFlags): void;

package/dist/src/daemon/session-store.d.ts

@@ -0,0 +1,32 @@
+import type { CommandFlags } from '../core/dispatch.ts';
+import type { SessionRuntimeHints, SessionState } from './types.ts';
+export declare class SessionStore {
+    private readonly sessions;
+    private readonly runtimeHints;
+    private readonly sessionsDir;
+    constructor(sessionsDir: string);
+    get(name: string): SessionState | undefined;
+    has(name: string): boolean;
+    set(name: string, session: SessionState): void;
+    delete(name: string): boolean;
+    values(): IterableIterator<SessionState>;
+    toArray(): SessionState[];
+    getRuntimeHints(name: string): SessionRuntimeHints | undefined;
+    setRuntimeHints(name: string, hints: SessionRuntimeHints): void;
+    clearRuntimeHints(name: string): boolean;
+    recordAction(session: SessionState, entry: {
+        command: string;
+        positionals: string[];
+        flags: CommandFlags;
+        result?: Record<string, unknown>;
+    }): void;
+    writeSessionLog(session: SessionState): void;
+    defaultTracePath(session: SessionState): string;
+    /** Path to session-scoped app log file. Agent can grep this for token-efficient debugging. */
+    resolveAppLogPath(sessionName: string): string;
+    resolveAppLogPidPath(sessionName: string): string;
+    static safeSessionName(name: string): string;
+    static expandHome(filePath: string, cwd?: string): string;
+    private resolveScriptPath;
+    private buildOptimizedActions;
+}

package/dist/src/daemon/snapshot-diff.d.ts

@@ -0,0 +1,20 @@
+import type { SnapshotNode } from '../utils/snapshot.ts';
+type SnapshotDiffLine = {
+    kind: 'added' | 'removed' | 'unchanged';
+    text: string;
+};
+type SnapshotDiffSummary = {
+    additions: number;
+    removals: number;
+    unchanged: number;
+};
+type SnapshotDiffResult = {
+    summary: SnapshotDiffSummary;
+    lines: SnapshotDiffLine[];
+};
+type SnapshotDiffOptions = {
+    flatten?: boolean;
+};
+export declare function buildSnapshotDiff(previousNodes: SnapshotNode[], currentNodes: SnapshotNode[], options?: SnapshotDiffOptions): SnapshotDiffResult;
+export declare function countSnapshotComparableLines(nodes: SnapshotNode[], options?: SnapshotDiffOptions): number;
+export {};

package/dist/src/daemon/snapshot-processing.d.ts

@@ -0,0 +1,8 @@
+import type { RawSnapshotNode, SnapshotState } from '../utils/snapshot.ts';
+export declare function findNodeByLabel(nodes: SnapshotState['nodes'], label: string): import("../index.ts").SnapshotNode | null;
+export declare function resolveRefLabel(node: SnapshotState['nodes'][number], nodes: SnapshotState['nodes']): string | undefined;
+export declare function pruneGroupNodes(nodes: RawSnapshotNode[]): RawSnapshotNode[];
+export declare function normalizeType(type: string): string;
+export declare function isFillableType(type: string, platform: 'ios' | 'android'): boolean;
+export declare function findNearestHittableAncestor(nodes: SnapshotState['nodes'], node: SnapshotState['nodes'][number]): SnapshotState['nodes'][number] | null;
+export declare function extractNodeText(node: SnapshotState['nodes'][number]): string;

package/dist/src/daemon/transport.d.ts

@@ -0,0 +1,6 @@
+import net from 'node:net';
+import type { Server as HttpServer } from 'node:http';
+import type { DaemonRequest, DaemonResponse } from './types.ts';
+export declare function createSocketServer(handleRequest: (req: DaemonRequest) => Promise<DaemonResponse>): net.Server;
+export declare function listenNetServer(server: net.Server): Promise<number>;
+export declare function listenHttpServer(server: HttpServer): Promise<number>;