@reticlehq/server 3.5.0 → 3.7.0

package/dist/features/harness/explore/disparity.js

@@ -0,0 +1,71 @@
+/**
+ * Two-way testing: the coding agent's verdict on a goal beside the Harness's, compared.
+ *
+ * The agent knows where everything is; the Harness starts with one sentence. Agent proved and
+ * Harness could not find is a discoverability finding (where a newcomer gives up), not noise. Only
+ * a DECIDED agent verdict (yes or no) on a claim naming the goal's text is compared: an undecided one
+ * says nothing either way, and a claim about something else is not the same goal.
+ */
+import { DisparityKind, JournalVerdictEffectSchema, MAX_DISPARITY_SEARCHED, Verified, VerifiedReason, } from '@reticlehq/core';
+/** The decided verdicts the connected agent itself made: actions no Harness drove. */
+export function agentVerdictsIn(actions) {
+    return actions.flatMap((action) => {
+        if (action.drivenBy !== undefined)
+            return [];
+        const parsed = JournalVerdictEffectSchema.safeParse(action.effect);
+        if (!parsed.success)
+            return [];
+        const { claim, verified } = parsed.data;
+        return Verified.YES === verified || Verified.NO === verified ? [{ claim, verified }] : [];
+    });
+}
+/** The comparison for one goal, or undefined when the agent made no decided claim about it. */
+export function disparityFor(check, agent, search) {
+    if (true === check.absent)
+        return undefined;
+    const wanted = comparable(check.text);
+    const said = agent.filter((v) => claimed(v.claim).includes(wanted)).at(-1);
+    if (said === undefined)
+        return undefined;
+    // On the page before the drive began: plainly findable, never "hard to find" (persona 22).
+    const alreadyShown = true === check.reason?.startsWith(VerifiedReason.ALREADY_TRUE);
+    const harnessYes = Verified.YES === check.verified || alreadyShown;
+    const agentYes = Verified.YES === said.verified;
+    const kind = agentYes
+        ? harnessYes
+            ? DisparityKind.FINDABLE
+            : DisparityKind.DISCOVERABILITY
+        : harnessYes
+            ? DisparityKind.AGENT_ASSUMPTION
+            : DisparityKind.DEFECT;
+    const searched = (search?.searched ?? []).slice(-MAX_DISPARITY_SEARCHED);
+    return {
+        goal: check.text,
+        kind,
+        agent: said,
+        harness: {
+            verified: asVerified(check.verified),
+            found: alreadyShown || (search?.found ?? harnessYes),
+            searched,
+            ...(search?.gaveUpAt === undefined ? {} : { gaveUpAt: search.gaveUpAt }),
+        },
+    };
+}
+/**
+ * Text as two writers of the same words would both put it: no case, no quote marks of any kind, one
+ * space. A claim reads `text containing ‘Free shipping threshold’`; the goal is the bare words.
+ */
+const comparable = (text) => text
+    .toLowerCase()
+    .replace(/["'“”‘’`]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+/**
+ * What a claim says IS there: its "the absence of …" clauses claim the opposite, so they are cut.
+ * ponytail: a clause ends at `;` or `)`, as `describeWaitTarget` writes them; a goal text holding
+ * either inside an absence would keep its tail.
+ */
+const ABSENCE = /the absence of [^;)]*/g;
+const claimed = (claim) => comparable(claim).replace(ABSENCE, '');
+const VERIFIED = new Set(Object.values(Verified));
+const asVerified = (value) => VERIFIED.has(value) ? value : Verified.UNKNOWN;

package/dist/features/harness/explore/fake-app.d.ts

@@ -0,0 +1,16 @@
+export interface FakePage {
+    tree: string;
+    /** Text on the page that is below the fold: a scroll-to finds it, a read of the tree does not. */
+    below?: readonly string[];
+    /** What pressing a ref does: go to a route, or show another tree on the same route (a menu). */
+    press?: Record<string, {
+        to: string;
+    } | {
+        opens: string;
+    }>;
+}
+export declare function fakeApp(pages: Record<string, FakePage>, start: string): {
+    invoke: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+    calls: [string, Record<string, unknown>][];
+    route: () => string;
+};

package/dist/features/harness/explore/fake-app.js

@@ -0,0 +1,49 @@
+/**
+ * A pretend app for the exploratory Harness's tests: pages by route, each a snapshot tree, some
+ * text only a scroll reaches, and what each control does when pressed. It answers the same tool
+ * calls the daemon's toolset does, so the search and the survey run against it unchanged.
+ */
+import { ReticleTool, asRecord } from '@reticlehq/core';
+export function fakeApp(pages, start) {
+    let route = start;
+    let overlay;
+    const calls = [];
+    const page = () => pages[route] ?? { tree: '- heading "Not found"' };
+    const tree = () => overlay ?? page().tree;
+    const invoke = (name, args) => {
+        calls.push([name, args]);
+        switch (name) {
+            case ReticleTool.SNAPSHOT:
+                return Promise.resolve({ tree: tree(), status: { route: `${route}` } });
+            case ReticleTool.NAVIGATE:
+                route = String(args['url']);
+                overlay = undefined;
+                return Promise.resolve({ ok: true, confirmed: true });
+            case ReticleTool.ACT:
+            case ReticleTool.ACT_AND_WAIT: {
+                const effect = page().press?.[String(args['ref'])];
+                if (effect !== undefined && 'to' in effect) {
+                    route = effect.to;
+                    overlay = undefined;
+                }
+                else if (effect !== undefined)
+                    overlay = effect.opens;
+                return Promise.resolve({ ok: true });
+            }
+            case ReticleTool.SCROLL_TO: {
+                const value = String(args['value']);
+                return Promise.resolve({
+                    found: tree().includes(value) || true === page().below?.includes(value),
+                });
+            }
+            case ReticleTool.ASSERT: {
+                const contains = String(asRecord(args['predicate'])['contains']);
+                const shown = tree().includes(contains) || true === page().below?.includes(contains);
+                return Promise.resolve({ verified: shown ? 'yes' : 'no' });
+            }
+            default:
+                return Promise.resolve({ pass: true });
+        }
+    };
+    return { invoke, calls, route: () => route };
+}

package/dist/features/harness/explore/goal-search.d.ts

@@ -0,0 +1,26 @@
+import type { HarnessMap } from '@reticlehq/core/artifacts';
+import { type Invoke } from './page-tree.js';
+/** Presses the hunt may spend: enough for a menu, its item and a tab, or a few toggles. */
+export declare const SEARCH_MOVES = 10;
+export interface GoalSearch {
+    found: boolean;
+    /** Where it was found. */
+    at?: string;
+    /** Each place looked at and each press made, in order: `/runs`, `/runs: button "Team"`. */
+    searched: string[];
+    /** The last place looked at, when it was not found. */
+    gaveUpAt?: string;
+}
+/** Hunt for `goal`, leaving the tab where it was found. */
+export declare function searchForGoal(invoke: Invoke, options: {
+    goal: string;
+    journey?: string;
+    map?: HarnessMap;
+    moves?: number;
+    /** Text the Harness wrote itself: a match inside it is not the goal found. */
+    own?: readonly string[];
+    /** The pages the drive reached, in order: the goal may be on one it left. */
+    reached?: readonly string[];
+}): Promise<GoalSearch>;
+/** The mapped pages that show the goal, then the ones the journey names by heading. */
+export declare function mappedPagesFor(map: HarnessMap | undefined, goal: string, journey: string): string[];

package/dist/features/harness/explore/goal-search.js

@@ -0,0 +1,144 @@
+/**
+ * Search before grading: a goal the drive did not end on is hunted for, the way a person would,
+ * before anything is said about it.
+ *
+ * Every Harness miss in the persona drives had one shape: it graded where it stood. It judged an
+ * Impact text on /runs, stopped one click short of "Team", read an empty search result as the
+ * answer, called an opened menu a wrong guess, and walked past a goal it had reached. This hunt is
+ * deterministic (no model) and bounded: from the page the drive ended on it tries the toggles and
+ * tabs, then the controls the journey names (a menu that opens is followed into its items), then the
+ * same page without its query, then the pages the map says show the goal, then the pages the drive
+ * reached. It never fills a field
+ * and never presses a name on the never-pressed list. Each place it looks is kept, so "not found"
+ * says where it searched, and a goal it did not find is undecided, never a failure.
+ */
+import { ReticleTool } from '@reticlehq/core';
+import { lookFor } from '../goals.js';
+import { journeyNames, namedControls, navLinks, overlayOpen, parseTree, readPage, toggles, withoutQuery, } from './page-tree.js';
+/** Presses the hunt may spend: enough for a menu, its item and a tab, or a few toggles. */
+export const SEARCH_MOVES = 10;
+/** Shortest heading matched against the journey; shorter ones match by accident. */
+const MIN_HEADING = 4;
+/** How deep a chain of presses goes from one page: menu, item, tab. */
+const MAX_DEPTH = 3;
+const label = (line) => `${line.role} "${line.name}"`;
+/** Hunt for `goal`, leaving the tab where it was found. */
+export async function searchForGoal(invoke, options) {
+    const { goal } = options;
+    const journey = options.journey ?? '';
+    const searched = [];
+    const looked = new Set();
+    const pressed = new Set();
+    let left = options.moves ?? SEARCH_MOVES;
+    let at;
+    let reopened = false;
+    /** Look here, then press what a person would press here, deeper while presses are left. */
+    const explore = async (depth) => {
+        const page = await readPage(invoke);
+        if (page === undefined)
+            return false;
+        searched.push(page.route);
+        looked.add(page.route);
+        if (await lookFor(invoke, goal, options.own)) {
+            at = page.route;
+            return true;
+        }
+        if (MAX_DEPTH <= depth)
+            return false;
+        // Read again, settled by the look: a page read as it loaded offered none of its controls.
+        const lines = parseTree((await readPage(invoke))?.tree ?? page.tree);
+        // A menu or dialog the drive left open hides the page behind it: the live drive's hunt read the
+        // workspace switcher and nothing else. Close it by reloading the page, once, and look again.
+        if (0 === depth && !reopened && overlayOpen(lines)) {
+            reopened = true;
+            return (await go(page.route)) && explore(0);
+        }
+        // What the journey names on this page first ("press Run plan"), then the toggles, then the
+        // named links that leave it: a switcher pressed as a toggle opened its menu over the plan page,
+        // and the button the journey named was never pressed.
+        const named = namedControls(lines, journey);
+        const leaving = new Set(navLinks(lines));
+        const tries = [
+            ...new Set([
+                ...named.filter((l) => !leaving.has(l)),
+                ...toggles(lines),
+                ...named.filter((l) => leaving.has(l)),
+            ].map(label)),
+        ];
+        const overlaid = overlayOpen(lines);
+        for (const name of tries) {
+            const key = `${page.route}: ${name}`;
+            if (pressed.has(key))
+                continue;
+            if (left <= 0)
+                return false;
+            // Found again on a fresh read: a ref does not survive the page coming back.
+            const now = await readPage(invoke);
+            const line = parseTree(now?.tree ?? '').find((l) => l.ref !== undefined && label(l) === name);
+            if (line?.ref === undefined)
+                continue;
+            pressed.add(key);
+            left -= 1;
+            searched.push(key);
+            try {
+                await invoke(ReticleTool.ACT, { ref: line.ref, action: 'click' });
+            }
+            catch {
+                continue;
+            }
+            if (await explore(depth + 1))
+                return true;
+            // Back where it pressed from, with nothing it opened left over the page to hide the rest.
+            const back = await readPage(invoke);
+            const leftOpen = !overlaid && overlayOpen(parseTree(back?.tree ?? ''));
+            if (back !== undefined && (back.route !== page.route || leftOpen))
+                await go(page.route);
+        }
+        return false;
+    };
+    const go = async (route) => {
+        try {
+            await invoke(ReticleTool.NAVIGATE, { url: route });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const start = await readPage(invoke);
+    if (await explore(0))
+        return { found: true, ...(at === undefined ? {} : { at }), searched };
+    // A search or a filter that emptied the list, undone.
+    const elsewhere = [
+        ...(start === undefined || withoutQuery(start.route) === start.route
+            ? []
+            : [withoutQuery(start.route)]),
+        ...mappedPagesFor(options.map, goal, journey),
+        // Newest first: the drive's last page before it moved on is where a saved thing shows.
+        ...[...(options.reached ?? [])].reverse(),
+    ];
+    for (const route of elsewhere) {
+        if (looked.has(route) || left <= 0)
+            continue;
+        if (!(await go(route)))
+            continue;
+        if (await explore(1))
+            return { found: true, ...(at === undefined ? {} : { at }), searched };
+    }
+    const gaveUpAt = searched.at(-1);
+    return { found: false, searched, ...(gaveUpAt === undefined ? {} : { gaveUpAt }) };
+}
+/** The mapped pages that show the goal, then the ones the journey names by heading. */
+export function mappedPagesFor(map, goal, journey) {
+    if (map === undefined)
+        return [];
+    const wanted = goal.toLowerCase();
+    const said = journey.toLowerCase();
+    const showing = map.pages.filter((p) => p.texts.some((t) => t.toLowerCase().includes(wanted)));
+    // A page whose controls name what the journey asks for: Memory is a link on Flows.
+    const leading = map.pages.filter((p) => p.controls.some((c) => journeyNames(said, /"([^"]*)"/.exec(c)?.[1] ?? '')));
+    const named = map.pages.filter((p) => p.heading !== undefined &&
+        MIN_HEADING <= p.heading.length &&
+        said.includes(p.heading.toLowerCase()));
+    return [...new Set([...showing, ...leading, ...named].map((p) => p.route))];
+}

package/dist/features/harness/explore/page-tree.d.ts

@@ -0,0 +1,49 @@
+export type Invoke = (name: string, args: Record<string, unknown>) => Promise<unknown>;
+/** One element line: `  - button "Team" (ref=e252) [pressed]`. */
+export interface TreeLine {
+    depth: number;
+    role: string;
+    name: string;
+    ref?: string;
+    states: string[];
+    /** The element's own text, `[text="…"]`, when it has no name to carry it. */
+    text?: string;
+    /** The roles of the lines it sits inside, nearest last. */
+    within: string[];
+}
+export interface PageRead {
+    route: string;
+    tree: string;
+}
+export declare function parseTree(tree: string): TreeLine[];
+/** The page's own address: path, query and hash, without the parameters Reticle adds. */
+export declare function routeOf(route: string): string;
+/** The same page with no query: a search or a filter undone. */
+export declare function withoutQuery(route: string): string;
+/** Read the page in full. Undefined when it cannot be read. */
+export declare function readPage(invoke: Invoke): Promise<PageRead | undefined>;
+/** Whether a menu or dialog is open, so the read shows it and little else. */
+export declare function overlayOpen(lines: readonly TreeLine[]): boolean;
+/** Links in the app's navigation: where a person goes to look around. */
+export declare function navLinks(lines: readonly TreeLine[]): (TreeLine & {
+    ref: string;
+})[];
+/**
+ * Toggles and tabs not already on: a button beside a pressed sibling (Mine | Team), and tabs, radios
+ * and switches. Pressing one changes what the page shows without leaving it.
+ */
+export declare function toggles(lines: readonly TreeLine[]): (TreeLine & {
+    ref: string;
+})[];
+/**
+ * Controls the journey names ("open Account, choose Settings, then Members and access"): the plan
+ * is a hint, and these are where it points. A name like `Account: Leo Martin · Pro` matches on the
+ * part before its colon.
+ */
+export declare function namedControls(lines: readonly TreeLine[], journey: string): (TreeLine & {
+    ref: string;
+})[];
+/** Whether the journey names a control: its name, or the part before its colon, as whole words. */
+export declare function journeyNames(journey: string, name: string): boolean;
+/** The words a page shows, as a reader would list them: headings, text and labels, not controls. */
+export declare function textsOf(lines: readonly TreeLine[], max: number): string[];

package/dist/features/harness/explore/page-tree.js

@@ -0,0 +1,148 @@
+/**
+ * A page as the exploratory Harness reads it: one full snapshot, and the controls on it that a
+ * person hunting for something would try — nav links, toggles and tabs, and whatever the journey
+ * names. Pure over the snapshot's line format (core's `snapshot-tree.ts`); no browser here.
+ */
+import { RETICLE_URL_PARAM, ReticleTool, asRecord } from '@reticlehq/core';
+const LINE = /^(\s*)-\s+([a-z]+)(?:\s+"((?:[^"\\]|\\.)*)")?(.*)$/;
+const REF = /\(ref=(e\d+)\)/;
+const STATES = /\[([a-z,]+)\]\s*$/;
+const OWN_TEXT = /\[text="((?:[^"\\]|\\.)*)"\]/;
+export function parseTree(tree) {
+    const out = [];
+    const stack = [];
+    for (const raw of tree.split('\n')) {
+        const m = LINE.exec(raw);
+        if (null === m)
+            continue;
+        const depth = (m[1] ?? '').length;
+        while (0 < stack.length && (stack.at(-1)?.depth ?? 0) >= depth)
+            stack.pop();
+        const rest = m[4] ?? '';
+        const ref = REF.exec(rest)?.[1];
+        const text = OWN_TEXT.exec(rest)?.[1];
+        out.push({
+            depth,
+            role: m[2] ?? '',
+            name: m[3] ?? '',
+            ...(ref === undefined ? {} : { ref }),
+            ...(text === undefined ? {} : { text }),
+            states: (STATES.exec(rest)?.[1] ?? '').split(',').filter((s) => 0 < s.length),
+            within: stack.map((s) => s.role),
+        });
+        stack.push({ depth, role: m[2] ?? '' });
+    }
+    return out;
+}
+/** The page's own address: path, query and hash, without the parameters Reticle adds. */
+export function routeOf(route) {
+    const [pathAndQuery = '', ...hash] = route.split('#');
+    const [path = '', query] = pathAndQuery.split('?');
+    const ours = Object.values(RETICLE_URL_PARAM);
+    const kept = (query ?? '')
+        .split('&')
+        .filter((pair) => 0 < pair.length && !ours.some((p) => pair.startsWith(`${p}=`)))
+        .join('&');
+    return `${path || '/'}${0 === kept.length ? '' : `?${kept}`}${0 === hash.length ? '' : `#${hash.join('#')}`}`;
+}
+/** The same page with no query: a search or a filter undone. */
+export function withoutQuery(route) {
+    const [pathAndQuery = '', ...hash] = route.split('#');
+    const path = pathAndQuery.split('?')[0] ?? '';
+    return `${0 === path.length ? '/' : path}${0 === hash.length ? '' : `#${hash.join('#')}`}`;
+}
+/** Read the page in full. Undefined when it cannot be read. */
+export async function readPage(invoke) {
+    try {
+        const result = asRecord(await invoke(ReticleTool.SNAPSHOT, { mode: 'full' }));
+        const tree = result['tree'];
+        const route = asRecord(result['status'])['route'];
+        return 'string' === typeof tree
+            ? { tree, route: routeOf('string' === typeof route ? route : '/') }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Names the hunt never presses: each is a write, or leaves the session. The action tool's own
+ * destructive-action gate still applies; this keeps the search from even asking.
+ */
+const NEVER_PRESSED = /\b(?:sign ?out|log ?out|delete|remove|leave|revoke|join|cancel|archive|reset|disconnect|accept|decline|mark as|resolve|ignore|invite|pay|buy|upgrade|save|submit|send|create|new)\b/i;
+const pressable = (line) => line.ref !== undefined && 0 < line.name.length && !NEVER_PRESSED.test(line.name);
+const NAV_LANDMARKS = new Set(['navigation', 'complementary', 'banner']);
+const TOGGLE_ROLES = new Set(['tab', 'radio', 'switch']);
+const TOGGLE_GROUPS = new Set(['group', 'toolbar', 'radiogroup', 'tablist']);
+/** Roles that, open, make the rest of the page inert to a reader. */
+const OVERLAYS = new Set(['menu', 'dialog', 'alertdialog', 'listbox']);
+/** Whether a menu or dialog is open, so the read shows it and little else. */
+export function overlayOpen(lines) {
+    return lines.some((l) => OVERLAYS.has(l.role));
+}
+const PRESSED = 'pressed';
+const CHECKED = 'checked';
+/** Links in the app's navigation: where a person goes to look around. */
+export function navLinks(lines) {
+    return lines.filter((l) => 'link' === l.role && l.within.some((r) => NAV_LANDMARKS.has(r)) && pressable(l));
+}
+/**
+ * Toggles and tabs not already on: a button beside a pressed sibling (Mine | Team), and tabs, radios
+ * and switches. Pressing one changes what the page shows without leaving it.
+ */
+export function toggles(lines) {
+    return lines.filter((l, i) => {
+        if (!pressable(l) || l.states.includes(PRESSED) || l.states.includes(CHECKED))
+            return false;
+        if (TOGGLE_ROLES.has(l.role))
+            return true;
+        // Only inside a group of its kind (Mine | Team, Map | List). A banner's "Hide sidebar" is
+        // pressed too, and the workspace switcher beside it was pressed as a toggle on a live drive.
+        if ('button' !== l.role || !TOGGLE_GROUPS.has(l.within.at(-1) ?? ''))
+            return false;
+        const siblings = [lines[i - 1], lines[i + 1]].filter((s) => s !== undefined && s.depth === l.depth && 'button' === s.role);
+        return siblings.some((s) => s.states.includes(PRESSED));
+    });
+}
+/** Shortest name matched against the journey's words; shorter ones match by accident. */
+const MIN_NAMED = 4;
+const ROLES_FOLLOWED = new Set(['link', 'button', 'menuitem', 'tab']);
+/**
+ * Controls the journey names ("open Account, choose Settings, then Members and access"): the plan
+ * is a hint, and these are where it points. A name like `Account: Leo Martin · Pro` matches on the
+ * part before its colon.
+ */
+export function namedControls(lines, journey) {
+    const said = journey.toLowerCase();
+    return lines.filter((l) => ROLES_FOLLOWED.has(l.role) && pressable(l) && journeyNames(said, l.name));
+}
+/** Whether the journey names a control: its name, or the part before its colon, as whole words. */
+export function journeyNames(journey, name) {
+    const head = (name.split(':')[0] ?? '').trim().toLowerCase();
+    return (MIN_NAMED <= head.length && new RegExp(`\\b${escape(head)}\\b`).test(journey.toLowerCase()));
+}
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Roles a person acts on rather than reads. */
+const INTERACTIVE = new Set([
+    'link',
+    'button',
+    'textbox',
+    'searchbox',
+    'checkbox',
+    'radio',
+    'switch',
+    'combobox',
+    'option',
+    'menuitem',
+    'tab',
+    'slider',
+    'spinbutton',
+]);
+/** The words a page shows, as a reader would list them: headings, text and labels, not controls. */
+export function textsOf(lines, max) {
+    const words = lines.flatMap((l) => [
+        ...(INTERACTIVE.has(l.role) || 0 === l.name.length ? [] : [l.name]),
+        ...(l.text === undefined ? [] : [l.text]),
+    ]);
+    return [...new Set(words)].slice(0, max);
+}

package/dist/features/harness/explore/site-map.d.ts

@@ -0,0 +1,34 @@
+import { type HarnessMap, type HarnessMapPage } from '@reticlehq/core/artifacts';
+import type { ToolOutcome } from '../harness.js';
+import { type Invoke, type PageRead } from './page-tree.js';
+/** Presses the survey may spend: a dashboard's navigation and its toggles, not its rows. */
+export declare const SURVEY_PRESSES = 12;
+/** A map older than this is surveyed again; a younger one is reused and refreshed from drives. */
+export declare const MAP_FRESH_MS: number;
+/**
+ * Whether the app was surveyed for the run that started at `since` (or there is no map at all): a
+ * run that reused a fresh map does not sweep the whole app again.
+ */
+export declare function surveyedSince(map: HarnessMap | undefined, since: number): boolean;
+/** One page read, as the map keeps it. */
+export declare function pageFrom(read: PageRead, at: number, reachedBy?: string): HarnessMapPage;
+/** Pages merged by route, the newest read winning, newest first, within the map's bound. */
+export declare function mergePages(map: HarnessMap, pages: readonly HarnessMapPage[], surveyedAt?: number): HarnessMap;
+/** The pages a drive read in full, for refreshing the map from what it saw. */
+export declare function pagesReadIn(calls: readonly ToolOutcome[], at: number): HarnessMapPage[];
+/**
+ * Survey the app from where the tab stands, and leave the tab where it started. Every press is
+ * found again by its name on a fresh read of the start page, since a ref does not survive a reload.
+ */
+export declare function surveyApp(invoke: Invoke, now: () => number, presses?: number): Promise<HarnessMap | undefined>;
+/** The map from its file's text, or undefined when there is none or it does not parse. */
+export declare function parseMap(text: string | undefined): HarnessMap | undefined;
+/** The map as the platform takes it: pages only, the fields its engine reads. */
+export declare function mapForPlatform(map: HarnessMap): {
+    pages: {
+        route: string;
+        heading?: string;
+        texts: string[];
+        controls: string[];
+    }[];
+};