@jitsusama/agentic-harness.core 0.1.0

package/dist/web/telemetry/downloads.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Files the page handed back.
+ *
+ * A download is the one result that never appears in the page,
+ * so without capturing it there is no way to check that an
+ * export button produced the right csv, or produced anything
+ * at all.
+ */
+/** Where a download got to. */
+export type DownloadState = "inProgress" | "completed" | "canceled";
+/** One file, from the moment the browser knew about it. */
+export interface DownloadRecord {
+    readonly guid: string;
+    readonly url: string;
+    readonly suggestedFilename: string;
+    readonly state: DownloadState;
+    readonly totalBytes?: number;
+    readonly receivedBytes?: number;
+    readonly filePath?: string;
+}
+/** The protocol events this fold consumes. */
+export type DownloadInput = {
+    readonly kind: "begin";
+    readonly guid: string;
+    readonly url: string;
+    readonly suggestedFilename: string;
+} | {
+    readonly kind: "progress";
+    readonly guid: string;
+    readonly state: DownloadState;
+    readonly totalBytes?: number;
+    readonly receivedBytes?: number;
+    readonly filePath?: string;
+};
+/** A running record of every file the page produced. */
+export interface DownloadRecorder {
+    apply(input: DownloadInput): void;
+    all(): readonly DownloadRecord[];
+}
+export declare function createDownloadRecorder(): DownloadRecorder;
+/** What the page has handed back. */
+export declare function renderDownloads(downloads: readonly DownloadRecord[]): string;

package/dist/web/telemetry/downloads.js

@@ -0,0 +1,65 @@
+/**
+ * Files the page handed back.
+ *
+ * A download is the one result that never appears in the page,
+ * so without capturing it there is no way to check that an
+ * export button produced the right csv, or produced anything
+ * at all.
+ */
+export function createDownloadRecorder() {
+    const byGuid = new Map();
+    return {
+        apply(input) {
+            if (input.kind === "begin") {
+                byGuid.set(input.guid, {
+                    guid: input.guid,
+                    url: input.url,
+                    suggestedFilename: input.suggestedFilename,
+                    state: "inProgress",
+                });
+                return;
+            }
+            const existing = byGuid.get(input.guid);
+            // Progress for a download that began before capture was on
+            // has no name or source, and a record without those says
+            // nothing worth saying.
+            if (!existing)
+                return;
+            byGuid.set(input.guid, {
+                ...existing,
+                state: input.state,
+                ...(input.totalBytes === undefined
+                    ? {}
+                    : { totalBytes: input.totalBytes }),
+                // A cancelled download reports zero received, which would
+                // otherwise overwrite the progress it really made.
+                ...(input.receivedBytes === undefined || input.state === "canceled"
+                    ? {}
+                    : { receivedBytes: input.receivedBytes }),
+                ...(input.filePath === undefined ? {} : { filePath: input.filePath }),
+            });
+        },
+        all() {
+            return [...byGuid.values()];
+        },
+    };
+}
+/** What the page has handed back. */
+export function renderDownloads(downloads) {
+    if (downloads.length === 0)
+        return "The page has not downloaded anything.";
+    return downloads
+        .map((download) => {
+        const size = download.totalBytes === undefined
+            ? ""
+            : ` (${download.totalBytes} bytes)`;
+        if (download.state === "completed") {
+            return `${download.suggestedFilename}${size}\n  ${download.filePath ?? "written, but the path was not reported"}`;
+        }
+        if (download.state === "canceled") {
+            return `${download.suggestedFilename}: cancelled before it finished`;
+        }
+        return `${download.suggestedFilename}: still arriving${size}`;
+    })
+        .join("\n");
+}

package/dist/web/telemetry/failure.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Saying what the network said, in the words a person can act on.
+ *
+ * A navigation that never arrives used to throw the driver's own
+ * error, wrapper and stack and all, out through an API whose
+ * documentation promised the opposite. The useful part of
+ * "net::ERR_INTERNET_DISCONNECTED at http://example.test/, waiting
+ * until networkidle2" is the first token, and the rest is noise
+ * that pushes it off the line.
+ *
+ * The message is the browser's; the tidying is ours, and it is
+ * only tidying. Nothing here decides whether a failure happened
+ * or invents a reason for one.
+ */
+/**
+ * Whether a failure means the tab died under the operation.
+ *
+ * Chrome reports the death to whoever was driving the tab before
+ * it announces the crash that caused it, so a caller that reads
+ * only "is a recovery under way" concludes no and hands its next
+ * call to the corpse. Recognising the failure is what lets the
+ * call wait for the replacement instead of being lost.
+ */
+export declare function diedWithTheTab(failure: string): boolean;
+/**
+ * The one line worth showing for a thrown navigation failure.
+ *
+ * Chrome's error code wins when there is one, since it is the
+ * thing worth searching for and the thing a reader recognises.
+ */
+export declare function failureText(error: unknown): string;

package/dist/web/telemetry/failure.js

@@ -0,0 +1,72 @@
+/**
+ * Saying what the network said, in the words a person can act on.
+ *
+ * A navigation that never arrives used to throw the driver's own
+ * error, wrapper and stack and all, out through an API whose
+ * documentation promised the opposite. The useful part of
+ * "net::ERR_INTERNET_DISCONNECTED at http://example.test/, waiting
+ * until networkidle2" is the first token, and the rest is noise
+ * that pushes it off the line.
+ *
+ * The message is the browser's; the tidying is ours, and it is
+ * only tidying. Nothing here decides whether a failure happened
+ * or invents a reason for one.
+ */
+/** Chrome's own error codes, which read well enough as they are. */
+const CHROME_CODE = /\b(net::[A-Z_]+)\b/;
+/** What the driver adds around the message, and we take off. */
+const DRIVER_NOISE = [
+    /^Error:\s*/i,
+    /^Navigation failed because\s*/i,
+    /\s+at\s+https?:\/\/\S+/,
+    /,?\s*waiting until\s+\S+/i,
+];
+/**
+ * What the driver says when the thing it was driving died.
+ *
+ * These are about the tab going away underneath a call, which is
+ * a different event from the network refusing to answer. A
+ * navigation that provokes a crash is aborted rather than
+ * detached, and it must not match: retrying it would kill the
+ * replacement tab as reliably as it killed the first one.
+ */
+const DIED_WITH_THE_TAB = [
+    /frame was detached/i,
+    /session closed/i,
+    /target closed/i,
+    /target crashed/i,
+];
+/**
+ * Whether a failure means the tab died under the operation.
+ *
+ * Chrome reports the death to whoever was driving the tab before
+ * it announces the crash that caused it, so a caller that reads
+ * only "is a recovery under way" concludes no and hands its next
+ * call to the corpse. Recognising the failure is what lets the
+ * call wait for the replacement instead of being lost.
+ */
+export function diedWithTheTab(failure) {
+    return DIED_WITH_THE_TAB.some((pattern) => pattern.test(failure));
+}
+/**
+ * The one line worth showing for a thrown navigation failure.
+ *
+ * Chrome's error code wins when there is one, since it is the
+ * thing worth searching for and the thing a reader recognises.
+ */
+export function failureText(error) {
+    const raw = error instanceof Error
+        ? error.message
+        : typeof error === "string"
+            ? error
+            : String(error);
+    const code = CHROME_CODE.exec(raw);
+    if (code?.[1])
+        return code[1];
+    const tidied = DRIVER_NOISE.reduce((said, noise) => said.replace(noise, ""), raw)
+        .split("\n")[0]
+        ?.trim();
+    // An error with nothing to say still has to say something, or
+    // the caller reports a failure with a blank reason.
+    return tidied && tidied.length > 0 ? tidied : "the navigation failed";
+}

package/dist/web/telemetry/har.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Recorded requests as an HTTP Archive.
+ *
+ * HAR is what every other tool reads, so exporting it is how a
+ * capture leaves here without being trapped in our own shape.
+ * The format has invariants of its own, and they are the reason
+ * this is a module rather than a JSON.stringify: entry.time has
+ * to equal the sum of the timings that are not -1, send, wait
+ * and receive have to be present and non-negative, and any
+ * field the spec does not define has to start with an
+ * underscore or a reader is entitled to reject the file.
+ *
+ * Where the protocol gives no answer, this says so with -1
+ * rather than guessing, and puts anything extra we do know in
+ * an underscore field instead of overstating a spec one.
+ */
+import type { NetworkRequest } from "./network.js";
+/** A name and value, as HAR writes headers and query parameters. */
+export interface HarPair {
+    readonly name: string;
+    readonly value: string;
+}
+/** HAR's per-request timing breakdown, in milliseconds. */
+export interface HarTimings {
+    readonly blocked: number;
+    readonly dns: number;
+    readonly connect: number;
+    readonly ssl: number;
+    readonly send: number;
+    readonly wait: number;
+    readonly receive: number;
+}
+/** One archived request and its reply. */
+export interface HarEntry {
+    readonly startedDateTime: string;
+    readonly time: number;
+    readonly request: {
+        readonly method: string;
+        readonly url: string;
+        readonly httpVersion: string;
+        readonly cookies: readonly HarPair[];
+        readonly headers: readonly HarPair[];
+        readonly queryString: readonly HarPair[];
+        readonly headersSize: number;
+        readonly bodySize: number;
+        readonly postData?: {
+            readonly mimeType: string;
+            readonly text: string;
+        };
+    };
+    readonly response: {
+        readonly status: number;
+        readonly statusText: string;
+        readonly httpVersion: string;
+        readonly cookies: readonly HarPair[];
+        readonly headers: readonly HarPair[];
+        readonly content: {
+            readonly size: number;
+            readonly mimeType: string;
+            readonly text?: string;
+            readonly encoding?: string;
+        };
+        readonly redirectURL: string;
+        readonly headersSize: number;
+        readonly bodySize: number;
+    };
+    readonly cache: Record<string, never>;
+    readonly timings: HarTimings;
+    readonly serverIPAddress?: string;
+    readonly connection?: string;
+    /** What the request was for, which HAR has no field for. */
+    readonly _resourceType?: string;
+    /** Why it failed, which HAR has no field for either. */
+    readonly _failure?: string;
+    /** Bytes over the wire including headers, which bodySize is not. */
+    readonly _transferredBytes?: number;
+}
+/** The archive itself. */
+export interface Har {
+    readonly log: {
+        readonly version: "1.2";
+        readonly creator: {
+            readonly name: string;
+            readonly version: string;
+        };
+        readonly pages: readonly unknown[];
+        readonly entries: readonly HarEntry[];
+    };
+}
+/** A body already fetched for a request, keyed by request id. */
+export interface HarOptions {
+    readonly bodies?: ReadonlyMap<string, {
+        body: string;
+        base64Encoded: boolean;
+    }>;
+}
+export declare function toHar(requests: readonly NetworkRequest[], options?: HarOptions): Har;

package/dist/web/telemetry/har.js

@@ -0,0 +1,227 @@
+/**
+ * Recorded requests as an HTTP Archive.
+ *
+ * HAR is what every other tool reads, so exporting it is how a
+ * capture leaves here without being trapped in our own shape.
+ * The format has invariants of its own, and they are the reason
+ * this is a module rather than a JSON.stringify: entry.time has
+ * to equal the sum of the timings that are not -1, send, wait
+ * and receive have to be present and non-negative, and any
+ * field the spec does not define has to start with an
+ * underscore or a reader is entitled to reject the file.
+ *
+ * Where the protocol gives no answer, this says so with -1
+ * rather than guessing, and puts anything extra we do know in
+ * an underscore field instead of overstating a spec one.
+ */
+/** What HAR uses for a measurement that does not apply. */
+const NOT_APPLICABLE = -1;
+/** Milliseconds in a second, for the protocol's seconds-based clocks. */
+const MS_PER_SECOND = 1000;
+export function toHar(requests, options = {}) {
+    return {
+        log: {
+            version: "1.2",
+            creator: { name: "pi browser-integration", version: "1" },
+            pages: [],
+            entries: requests.map((request) => entryOf(request, options)),
+        },
+    };
+}
+/** One request, in the shape a HAR reader expects. */
+function entryOf(request, options) {
+    const timings = timingsOf(request);
+    const body = options.bodies?.get(request.id);
+    const contentType = headerOf(request.responseHeaders, "content-type");
+    const location = headerOf(request.responseHeaders, "location");
+    return {
+        startedDateTime: startedAt(request),
+        // The spec requires this to be the sum, so it is computed
+        // from the parts rather than from the measured duration,
+        // which would usually differ by a rounding.
+        time: total(timings),
+        request: {
+            method: request.method,
+            url: request.url,
+            httpVersion: "",
+            cookies: [],
+            headers: pairsOf(request.requestHeaders),
+            queryString: queryOf(request.url),
+            headersSize: NOT_APPLICABLE,
+            bodySize: request.postData ? request.postData.length : NOT_APPLICABLE,
+            ...(request.postData === undefined
+                ? {}
+                : {
+                    postData: {
+                        mimeType: headerOf(request.requestHeaders, "content-type") ?? "",
+                        text: request.postData,
+                    },
+                }),
+        },
+        response: {
+            status: request.status ?? 0,
+            statusText: request.statusText ?? "",
+            httpVersion: "",
+            cookies: [],
+            headers: pairsOf(request.responseHeaders),
+            content: {
+                // Bytes, not characters. This was the length of whatever
+                // string we were holding, which for a base64 body is a
+                // third larger than the content and for text is UTF-16
+                // code units. A body we never fetched now says -1, the
+                // same way bodySize does four lines below, rather than
+                // claiming the response was empty.
+                size: body === undefined ? NOT_APPLICABLE : sizeOf(body),
+                mimeType: request.mimeType ?? contentType ?? "",
+                ...(body === undefined ? {} : { text: body.body }),
+                ...(body?.base64Encoded ? { encoding: "base64" } : {}),
+            },
+            // Empty rather than absent: the field is required, and a
+            // reader distinguishes "no redirect" from "not recorded".
+            redirectURL: location ?? "",
+            headersSize: NOT_APPLICABLE,
+            // The protocol counts bytes over the wire, headers
+            // included, which is not what bodySize means. Saying -1 is
+            // honest; the number we do have goes in its own field.
+            bodySize: NOT_APPLICABLE,
+        },
+        cache: {},
+        timings,
+        ...(request.remoteAddress === undefined
+            ? {}
+            : { serverIPAddress: request.remoteAddress }),
+        _resourceType: request.resourceType,
+        ...(request.failure === undefined ? {} : { _failure: request.failure }),
+        ...(request.transferredBytes === undefined
+            ? {}
+            : { _transferredBytes: request.transferredBytes }),
+    };
+}
+/**
+ * When the request started, on a clock that means something.
+ *
+ * The protocol's own timestamp is monotonic and has no relation
+ * to any calendar, so the wall clock is the only one that can
+ * answer this. Without it there is nothing honest to say, and
+ * the epoch is the conventional placeholder.
+ */
+function startedAt(request) {
+    const seconds = request.wallTimeSeconds;
+    return seconds === undefined
+        ? new Date(0).toISOString()
+        : new Date(seconds * MS_PER_SECOND).toISOString();
+}
+/**
+ * The phases of the request, in HAR's vocabulary.
+ *
+ * The protocol reports offsets in milliseconds from the moment
+ * the request began, with -1 for a phase that did not happen.
+ * HAR wants durations instead, and treats -1 the same way, so
+ * the translation is subtraction where both ends are real and
+ * -1 wherever either is not.
+ */
+function timingsOf(request) {
+    const timing = request.timing;
+    if (!timing) {
+        // Nothing was measured. Rather than invent a breakdown, put
+        // the whole measured duration in receive, which keeps the
+        // sum invariant true and the total honest.
+        return {
+            blocked: NOT_APPLICABLE,
+            dns: NOT_APPLICABLE,
+            connect: NOT_APPLICABLE,
+            ssl: NOT_APPLICABLE,
+            send: 0,
+            wait: 0,
+            receive: Math.max(0, request.durationMs ?? 0),
+        };
+    }
+    const dns = span(timing.dnsStart, timing.dnsEnd);
+    const connect = span(timing.connectStart, timing.connectEnd);
+    const ssl = span(timing.sslStart, timing.sslEnd);
+    const send = Math.max(0, span(timing.sendStart, timing.sendEnd));
+    const wait = Math.max(0, span(timing.sendEnd, timing.receiveHeadersEnd));
+    // Whatever came before the first phase that happened is time
+    // the request spent queued.
+    const firstPhase = [timing.dnsStart, timing.connectStart, timing.sendStart]
+        .filter((offset) => offset !== undefined && offset >= 0)
+        .sort((left, right) => left - right)[0];
+    const blocked = firstPhase === undefined ? NOT_APPLICABLE : firstPhase;
+    // Everything after the headers arrived was spent reading the
+    // body, when we know how long the whole thing took.
+    const headersDone = timing.receiveHeadersEnd ?? 0;
+    const receive = request.durationMs === undefined
+        ? 0
+        : Math.max(0, request.durationMs - headersDone);
+    return { blocked, dns, connect, ssl, send, wait, receive };
+}
+/** A duration between two offsets, or -1 if either did not happen. */
+function span(start, end) {
+    if (start === undefined || end === undefined)
+        return NOT_APPLICABLE;
+    if (start < 0 || end < 0)
+        return NOT_APPLICABLE;
+    return end - start;
+}
+/**
+ * The sum HAR requires entry.time to equal.
+ *
+ * ssl is deliberately left out. HAR 1.2 says the TLS handshake
+ * time is also included in connect, and the protocol agrees:
+ * sslStart and sslEnd sit inside connectStart and connectEnd. So
+ * summing every field counted the handshake twice and overstated
+ * the duration of every https request in the archive, in the one
+ * file whose header names this invariant as its reason to exist.
+ */
+function total(timings) {
+    const counted = [
+        "blocked",
+        "dns",
+        "connect",
+        "send",
+        "wait",
+        "receive",
+    ];
+    return counted
+        .map((field) => timings[field])
+        .filter((value) => value !== undefined && value >= 0)
+        .reduce((sum, value) => sum + value, 0);
+}
+/**
+ * How many bytes a captured body is.
+ *
+ * A base64 body carries four characters for every three bytes,
+ * and a text body counts UTF-16 code units rather than the bytes
+ * that crossed the wire, so neither string's length is a size.
+ */
+function sizeOf(body) {
+    return body.base64Encoded
+        ? Buffer.from(body.body, "base64").length
+        : Buffer.byteLength(body.body, "utf8");
+}
+/** Headers as HAR's name and value pairs. */
+function pairsOf(headers) {
+    return Object.entries(headers ?? {}).map(([name, value]) => ({
+        name,
+        value,
+    }));
+}
+/** One header, found without caring how it was capitalized. */
+function headerOf(headers, wanted) {
+    const found = Object.entries(headers ?? {}).find(([name]) => name.toLowerCase() === wanted);
+    return found?.[1];
+}
+/** The query string, split the way a url says it splits. */
+function queryOf(url) {
+    try {
+        return [...new URL(url).searchParams].map(([name, value]) => ({
+            name,
+            value,
+        }));
+    }
+    catch {
+        // A url the URL parser rejects has no query worth reporting,
+        // and failing the whole export over it would be worse.
+        return [];
+    }
+}

package/dist/web/telemetry/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Telemetry: what the page did while nobody was looking.
+ *
+ * Buffers here are plain data structures over serializable
+ * entries, so a record captured from CDP, from a fixture or
+ * from another driver is read the same way.
+ */
+export { type BufferLimits, createRingBuffer, type Recorded, type RingBuffer, } from "./buffer.js";
+export { type BrowserLogged, browserEntry, type CallFrame, type ConsoleCalled, consoleEntry, consoleText, type ExceptionThrown, exceptionEntry, type LogEntry, type RemoteArg, type RemotePreview, type RemotePreviewProperty, renderArg, } from "./console.js";
+export { answerFor, DEFAULT_DIALOG_POLICY, type DialogEvent, type DialogKind, type DialogPolicy, renderDialogs, } from "./dialogs.js";
+export { createDownloadRecorder, type DownloadInput, type DownloadRecord, type DownloadRecorder, type DownloadState, renderDownloads, } from "./downloads.js";
+export { diedWithTheTab, failureText } from "./failure.js";
+export { type Har, type HarEntry, type HarOptions, type HarPair, type HarTimings, toHar, } from "./har.js";
+export { createLifecycleRecorder, type LifecycleEvent, type LifecycleInput, type LifecycleKind, type LifecycleRecorder, renderLifecycle, strandedByCrash, } from "./lifecycle.js";
+export { createNetworkRecorder, type LoadingFailed, type LoadingFinished, type NetworkEvent, type NetworkRecorder, type NetworkRequest, type RedirectHop, type RequestSent, type RequestState, type ResourceTiming, type ResponseReceived, } from "./network.js";
+export { anyUrlShortened, type RequestQuery, renderRequests, requestStatus, } from "./requests.js";
+export { foldSockets, renderSockets, type SocketEvent, type SocketFrame, type SocketRecord, } from "./sockets.js";
+export { type Captured, renderLogs } from "./view.js";

package/dist/web/telemetry/index.js

@@ -0,0 +1,18 @@
+/**
+ * Telemetry: what the page did while nobody was looking.
+ *
+ * Buffers here are plain data structures over serializable
+ * entries, so a record captured from CDP, from a fixture or
+ * from another driver is read the same way.
+ */
+export { createRingBuffer, } from "./buffer.js";
+export { browserEntry, consoleEntry, consoleText, exceptionEntry, renderArg, } from "./console.js";
+export { answerFor, DEFAULT_DIALOG_POLICY, renderDialogs, } from "./dialogs.js";
+export { createDownloadRecorder, renderDownloads, } from "./downloads.js";
+export { diedWithTheTab, failureText } from "./failure.js";
+export { toHar, } from "./har.js";
+export { createLifecycleRecorder, renderLifecycle, strandedByCrash, } from "./lifecycle.js";
+export { createNetworkRecorder, } from "./network.js";
+export { anyUrlShortened, renderRequests, requestStatus, } from "./requests.js";
+export { foldSockets, renderSockets, } from "./sockets.js";
+export { renderLogs } from "./view.js";

package/dist/web/telemetry/lifecycle.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Where the page went, and whether it survived the trip.
+ *
+ * A session's readings are only meaningful against the document
+ * they were taken from, so a navigation is a fact worth keeping
+ * beside them. A crash is worth keeping for a stronger reason:
+ * everything recorded after one belongs to a different tab.
+ */
+/** What happened to the page. */
+export type LifecycleKind = "navigated" | "routeChanged" | "crashed" | "recovered";
+/** One thing that happened to the page. */
+export interface LifecycleEvent {
+    readonly kind: LifecycleKind;
+    readonly url?: string;
+    /**
+     * How an in-page route change was made. Chrome reports
+     * pushState and replaceState identically as "historyApi", so
+     * this never claims to know which was called.
+     */
+    readonly via?: string;
+    /** Why Chrome said the navigation was happening, when it said. */
+    readonly reason?: string;
+}
+/** The protocol events this fold consumes. */
+export type LifecycleInput = {
+    readonly kind: "requested";
+    readonly frameId: string;
+    readonly reason: string;
+} | {
+    readonly kind: "navigated";
+    readonly frameId: string;
+    readonly url: string;
+} | {
+    readonly kind: "within";
+    readonly frameId: string;
+    readonly url: string;
+    readonly navigationType?: string;
+} | {
+    readonly kind: "crashed";
+} | {
+    readonly kind: "recovered";
+    readonly url?: string;
+};
+/** A running record of where the page has been. */
+export interface LifecycleRecorder {
+    apply(input: LifecycleInput): void;
+    all(): readonly LifecycleEvent[];
+    /** Follow a new main frame, after a recovery replaced the tab. */
+    adoptFrame(frameId: string): void;
+}
+/**
+ * Whether the session is sitting on the tab that replaced a crash.
+ *
+ * A crash is not the end of a session: the tab is replaced and
+ * everything goes on working. What is not restored is where the
+ * session was, because the replacement starts blank and nothing
+ * sends it back. So every read after a crash describes a blank
+ * page, and describing a blank page accurately is the problem:
+ * an empty outline reads as a page with nothing on it rather
+ * than a page that is gone.
+ *
+ * Asked of the history rather than of the url, because the
+ * question is whether anything has been loaded since, and a
+ * session deliberately sitting on about:blank is not stranded.
+ */
+export declare function strandedByCrash(history: readonly LifecycleEvent[]): boolean;
+export declare function createLifecycleRecorder(mainFrameId: string): LifecycleRecorder;
+/** Where the page has been, in order. */
+export declare function renderLifecycle(events: readonly LifecycleEvent[]): string;