@better-fs-tools/read 0.0.0-tegami-trusted-publish-setup → 0.2.0

package/dist/classifiers/utf8.js

@@ -0,0 +1,61 @@
+import { startsWith, unsupported } from "./shared.js";
+/**
+ * Accepts UTF-8 text and refuses invalid UTF-8 with UNKNOWN_ENCODING, also when
+ * the invalid bytes come after the sample. The only built-in that returns text.
+ */
+export function utf8Classifier(options = {}) {
+    const refuse = (sample) => unsupported("UNKNOWN_ENCODING", null, ["invalid-utf8"], sample, options.note, "a byte or encoding-aware tool");
+    const classify = (sample) => {
+        const decoded = decodeStrict(sample.bytes);
+        if (decoded.kind === "invalid" || (decoded.kind === "incomplete" && sample.complete)) {
+            return refuse(sample);
+        }
+        const text = decoded.text.replace(/^/u, "");
+        const reasons = ["utf8"];
+        const hasBom = startsWith(sample.bytes, [0xef, 0xbb, 0xbf]);
+        if (hasBom)
+            reasons.push("utf8-bom");
+        if (decoded.kind === "incomplete")
+            reasons.push("incomplete-sample-suffix");
+        const svg = looksLikeSvg(text);
+        if (svg)
+            reasons.push("svg-text");
+        const notes = hasBom
+            ? [
+                {
+                    code: "utf8-bom",
+                    severity: "info",
+                    message: "The file begins with a UTF-8 byte order mark, which is included in line 1.",
+                },
+            ]
+            : [];
+        return {
+            kind: "text",
+            mimeType: svg ? "image/svg+xml" : (sample.mimeType ?? "text/plain"),
+            confidence: decoded.kind === "incomplete" ? "medium" : "high",
+            reasons,
+            ...(notes.length > 0 ? { notes } : {}),
+        };
+    };
+    return Object.freeze({ id: "utf8", classify, encodingFailure: refuse });
+}
+function decodeStrict(bytes) {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let text;
+    try {
+        text = decoder.decode(bytes, { stream: true });
+    }
+    catch {
+        return { kind: "invalid", text: "" };
+    }
+    try {
+        decoder.decode();
+    }
+    catch {
+        return { kind: "incomplete", text };
+    }
+    return { kind: "complete", text };
+}
+function looksLikeSvg(text) {
+    return /^\s*(?:<\?xml[^>]*>\s*)?(?:<!--[\s\S]*?-->\s*)?<svg(?:\s|>)/iu.test(text.slice(0, 4_096));
+}

package/dist/contract/base.d.ts

@@ -0,0 +1,126 @@
+import type { ListOutcome, PathOps } from "@better-fs-tools/fs";
+import type { Clock, Digest } from "./digest.ts";
+import type { JsonObject } from "./json.ts";
+/** Per-call context. Tools pass `host` through to extensions and never read it. */
+export interface ToolCallContext<THost = undefined> {
+    readonly signal?: AbortSignal;
+    /** The framework's tool call id, when it has one. */
+    readonly callId?: string;
+    readonly host: THost;
+}
+/** "read", "edit", "write", "apply_patch", "bash", or a host tool. */
+export type ToolName = "read" | "edit" | "write" | "apply_patch" | "bash" | (string & {});
+/** A note any tool can emit. */
+export interface Note {
+    /** Stable identifier, in kebab case, for example "denied" or "clamped". */
+    readonly code: string;
+    readonly severity: "info" | "warning";
+    readonly message: string;
+    readonly data?: JsonObject;
+}
+/**
+ * The error of a result with status "error", in every tool. `code` is
+ * UPPER_SNAKE. The result's error note has the same code in kebab case, and
+ * `message` and `data` are copied from that note.
+ */
+export interface ToolError<TCode extends string = string, TPhase extends string = string> {
+    readonly code: TCode;
+    /** The stage that failed. */
+    readonly phase: TPhase;
+    /** The error note's message. */
+    readonly message: string;
+    /** The error note's data, when it has any. */
+    readonly data?: JsonObject;
+}
+/** Wording that shared helpers use. Every tool's catalog extends it. */
+export interface ToolMessages {
+    pathRepaired(c: {
+        from: string;
+        to: string;
+    }): string;
+    denied(c: {
+        path: string;
+        detail: string | null;
+    }): string;
+}
+/** Given to every tool-neutral host function. */
+export interface ToolHookContext<THost = undefined> {
+    readonly tool: ToolName;
+    readonly messages: Readonly<ToolMessages>;
+    readonly digest: Digest | null;
+    readonly clock: Clock;
+    /** The same object for every stage of one call. */
+    readonly call: ToolCallContext<THost>;
+}
+export interface ToolResolveContext<THost = undefined> extends ToolHookContext<THost> {
+    readonly paths: PathOps;
+    /** Authorizes and lists a directory. A second call in the same stage returns an error outcome. */
+    list(dir: string): Promise<ListOutcome>;
+}
+export interface PathResolver<THost = undefined> {
+    readonly id: string;
+    resolve(path: string, ctx: ToolResolveContext<THost>): ResolveOutcome | Promise<ResolveOutcome>;
+}
+export type ResolveOutcome = {
+    readonly kind: "path";
+    readonly path: string;
+    readonly note?: Note;
+} | {
+    readonly kind: "not-found";
+    readonly note?: Note;
+};
+/** The fields every authorize target has. */
+export interface AccessTarget {
+    readonly action: string;
+    readonly requestedPath: string;
+    readonly resolvedPath: string;
+    readonly displayPath: string;
+}
+export type AccessDecision = {
+    readonly allow: true;
+    readonly notes?: readonly Note[];
+} | {
+    readonly allow: false;
+    readonly note?: Note;
+};
+/** An authorizer that works for every tool. It sees only the fields every target has. */
+export interface ToolAuthorizer<THost = undefined> {
+    readonly id: string;
+    readonly authorize: (target: AccessTarget, ctx: ToolHookContext<THost>) => AccessDecision | Promise<AccessDecision>;
+}
+/**
+ * The model-facing side of a tool: its name, description, JSON Schema, and the
+ * map from model input to the tool's canonical input. `TParam` is the tool's
+ * canonical parameter names.
+ */
+export interface ToolSignature<TInput, TParam extends string = string> {
+    /** The tool name the model sees. */
+    readonly name: string;
+    readonly description: string;
+    /** Plain JSON Schema with a description on each parameter. */
+    readonly schema: JsonObject;
+    /** Validates model input and maps it to canonical input. Throws TypeError that names host parameters. */
+    toInput(input: unknown): TInput;
+    /**
+     * Host name for a canonical parameter, for messages. An empty string means
+     * the signature has no such parameter, and messages leave out the advice
+     * that names it.
+     */
+    param(name: TParam): string;
+    /** Set on freeform signatures. Hosts that support grammar tools use it. */
+    readonly grammar?: {
+        readonly lark: string;
+    };
+}
+/**
+ * The options every signature preset takes. `TParam` is the preset's own
+ * parameter names. `names` gives a parameter another name in the schema, and
+ * `describe` replaces its description. Both are keyed by the preset's names.
+ */
+export interface SignatureDocs<TParam extends string> {
+    /** The tool name. */
+    readonly name?: string;
+    readonly description?: string;
+    readonly describe?: Partial<Record<TParam, string>>;
+    readonly names?: Partial<Record<TParam, string>>;
+}

package/dist/contract/classify.d.ts

@@ -0,0 +1,50 @@
+import type { JsonObject } from "./json.ts";
+import type { Confidence, ReadNote } from "./result.ts";
+export interface Classifier {
+    readonly id: string;
+    classify(sample: ClassificationSample): Classification | null;
+    /** Refusal for invalid UTF-8 found after the sample was accepted as text. */
+    encodingFailure?(sample: ClassificationSample): UnsupportedClassification | null;
+}
+export interface ClassificationSample {
+    /** At most limits.sampleBytes. */
+    readonly bytes: Uint8Array;
+    /** True when the sample is the whole file. */
+    readonly complete: boolean;
+    /** Display path, for extension hints. */
+    readonly path: string;
+    /** MIME type reported by the backend, if any. */
+    readonly mimeType: string | null;
+}
+export type Classification = TextClassification | UnsupportedClassification;
+export interface TextClassification {
+    readonly kind: "text";
+    readonly mimeType: string | null;
+    readonly confidence: Confidence;
+    readonly reasons: readonly string[];
+    readonly notes?: readonly ReadNote[];
+}
+export interface UnsupportedClassification {
+    readonly kind: "unsupported";
+    readonly code: string;
+    readonly mimeType: string | null;
+    readonly confidence: Confidence;
+    readonly reasons: readonly string[];
+    /** The refusal the model sees. */
+    readonly note: ReadNote;
+}
+export interface NoteOverride {
+    readonly code?: string;
+    readonly severity?: "info" | "warning";
+    readonly message?: string | ((context: NoteContext) => string);
+    readonly data?: JsonObject;
+}
+export interface NoteContext {
+    readonly path: string;
+    readonly mimeType: string | null;
+    readonly reasons: readonly string[];
+}
+export type BuiltInUnsupportedCode = "BINARY" | "IMAGE" | "PDF" | "NOTEBOOK" | "OFFICE_DOCUMENT" | "UNKNOWN_ENCODING";
+export interface DefaultClassifierOptions {
+    readonly notes?: Partial<Record<BuiltInUnsupportedCode, NoteOverride>>;
+}

package/dist/contract/context.d.ts

@@ -0,0 +1,13 @@
+import type { ToolCallContext } from "./base.ts";
+import type { ReadInput } from "./input.ts";
+import type { ReadResult } from "./result.ts";
+/** Per-call context for the read tool. The tool passes `host` through to extensions and never reads it. */
+export interface ReadContext<THost = undefined> extends ToolCallContext<THost> {
+}
+/**
+ * The context argument is optional, and `host` may be left out, when THost
+ * includes undefined. Otherwise both are required.
+ */
+export type ReadTool<THost = undefined> = undefined extends THost ? (input: ReadInput, ctx?: Omit<ReadContext<THost>, "host"> & {
+    readonly host?: THost;
+}) => Promise<ReadResult> : (input: ReadInput, ctx: ReadContext<THost>) => Promise<ReadResult>;

package/dist/contract/deps.d.ts

@@ -0,0 +1,60 @@
+import type { FileSystem } from "@better-fs-tools/fs";
+import type { Classifier } from "./classify.ts";
+import type { ReadContext } from "./context.ts";
+import type { Clock, Digest } from "./digest.ts";
+import type { Converter, PathResolver, ReadAuthorizer, ReadHook, Suggest, ViewBudget } from "./extensions.ts";
+import type { ReadFormatter } from "./format.ts";
+import type { ReadLimits } from "./limits.ts";
+import type { ReadMessageCatalog } from "./messages.ts";
+import type { ReadStateStore } from "./state.ts";
+export interface ReadDependencies<THost = undefined> {
+    /** A filesystem, or a factory called once for each read. */
+    readonly fs: FileSystem | ((call: ReadContext<THost>) => FileSystem);
+    readonly limits: Readonly<ReadLimits>;
+    readonly messages: Readonly<ReadMessageCatalog>;
+    /** Ordered. First classifier with an opinion wins. Non-empty. */
+    readonly classifiers: readonly Classifier[];
+    /** Rewrites the requested path before it is opened. null leaves it unchanged. */
+    readonly resolve: PathResolver<THost> | null;
+    /** Suggests names for a NOT_FOUND note from a listing of the parent directory. null turns suggestions off. */
+    readonly suggest: Suggest<THost> | null;
+    /** Host access policy for the opened file ("read") and before every listing ("list"). null allows everything. */
+    readonly authorize: ReadAuthorizer<THost> | null;
+    /** File converters in order: the first that accepts runs. The first directory converter lists directories. */
+    readonly converters: readonly Converter<THost>[];
+    /** Stops the view early, at a line boundary, when the next line would pass `max`. null has no budget. */
+    readonly budget: ViewBudget | null;
+    /** Run in order on every outcome that has a request, except ABORTED, before state is recorded. */
+    readonly hooks: readonly ReadHook<THost>[];
+    /** A store, or a factory called at most once for each read, and only when needed. Needs `digest`. */
+    readonly state: ReadStateStore | ((call: ReadContext<THost>) => ReadStateStore | null) | null;
+    readonly digest: Digest | null;
+    readonly clock: Clock;
+    readonly formatter: ReadFormatter<THost>;
+}
+/**
+ * `state` needs a `digest`, because a stored record names the digest that made
+ * it. `state` without `digest` does not type-check, and throws TypeError at run
+ * time.
+ */
+export type StateNeedsDigest = {
+    readonly state?: null;
+} | {
+    readonly digest: Digest;
+};
+/**
+ * The same pairing for a factory with its own default digest, such as the
+ * Node and Pi factories. Leave `digest` out to get the default. `digest: null`
+ * turns it off, and then `state` must be left out or null.
+ */
+export type StateNeedsDigestOrDefault = {
+    readonly state?: null;
+    readonly digest: null;
+} | {
+    readonly digest?: Digest;
+};
+export type ReadToolDeps<THost = undefined> = {
+    readonly fs: ReadDependencies<THost>["fs"];
+    readonly limits?: Partial<ReadLimits>;
+    readonly messages?: Partial<ReadMessageCatalog>;
+} & Partial<Omit<ReadDependencies<THost>, "fs" | "limits" | "messages">>;

package/dist/contract/digest.d.ts

@@ -0,0 +1,13 @@
+export interface Digest {
+    readonly id: string;
+    /** Incremental hash over scanned bytes. */
+    create(): DigestStream;
+    /** One-shot hash of a string. */
+    hash(value: string): string;
+}
+export interface DigestStream {
+    update(bytes: Uint8Array): void;
+    digest(): string;
+}
+/** Returns the current time. Every tool and `memoryStore` take this clock type. */
+export type Clock = () => Date;

package/dist/contract/extensions.d.ts

@@ -0,0 +1,115 @@
+import type { DirectoryEntry, ListOutcome, OpenFileInfo } from "@better-fs-tools/fs";
+import type { AccessTarget, ToolHookContext, ToolResolveContext } from "./base.ts";
+import type { Classification, ClassificationSample } from "./classify.ts";
+import type { ReadContext } from "./context.ts";
+import type { ReadRequest } from "./input.ts";
+import type { ReadLimits } from "./limits.ts";
+import type { ReadMessageCatalog } from "./messages.ts";
+import type { ContentPart, ReadNote, ReadReport } from "./result.ts";
+import type { ReadRecord } from "./state.ts";
+/** Given to every host function that runs during a call. */
+export interface ReadHookContext<THost = undefined> extends ToolHookContext<THost> {
+    readonly tool: "read";
+    readonly request: ReadRequest;
+    readonly limits: Readonly<ReadLimits>;
+    readonly messages: Readonly<ReadMessageCatalog>;
+    /** Same object for every stage of one call. */
+    readonly call: ReadContext<THost>;
+}
+/** Given to a resolver. It fits ToolResolveContext, so one resolver works for every tool. */
+export interface ReadResolveContext<THost = undefined> extends ReadHookContext<THost>, Pick<ToolResolveContext<THost>, "paths" | "list"> {
+}
+export type { PathResolver, ResolveOutcome } from "./base.ts";
+export type Suggest<THost = undefined> = (ctx: SuggestContext<THost>) => readonly string[];
+export interface SuggestContext<THost = undefined> {
+    /** The path that missed. */
+    readonly path: string;
+    readonly name: string;
+    readonly entries: readonly DirectoryEntry[];
+    readonly entriesTruncated: boolean;
+    /** limits.maxSuggestions. Names past it are dropped. */
+    readonly max: number;
+    readonly call: ReadContext<THost>;
+}
+export interface ReadAuthorizer<THost = undefined> {
+    readonly id: string;
+    readonly authorize: (target: ReadAuthorizeTarget, ctx: ReadHookContext<THost>) => ReadAuthorizeDecision | Promise<ReadAuthorizeDecision>;
+}
+export interface ReadAuthorizeTarget extends AccessTarget {
+    readonly action: "read" | "list";
+    /** Realpath for "read". Lexical directory path for "list". */
+    readonly resolvedPath: string;
+    readonly size: number | null;
+    readonly mtimeMs: number | null;
+}
+/** AccessDecision with read notes, so a denial can carry a retry. A ToolAuthorizer's decision fits it. */
+export type ReadAuthorizeDecision = {
+    readonly allow: true;
+    readonly notes?: readonly ReadNote[];
+} | {
+    readonly allow: false;
+    readonly note?: ReadNote;
+};
+export type Converter<THost = undefined> = FileConverter<THost> | DirectoryConverter<THost>;
+export interface ConverterMatch {
+    readonly classification: Classification;
+    readonly classifier: string;
+    readonly sample: ClassificationSample;
+}
+export interface FileConverter<THost = undefined> {
+    readonly id: string;
+    readonly target: "file";
+    /** Whether this converter handles the match. The only place a converter may decline. */
+    accepts(match: ConverterMatch): boolean;
+    convert(input: FileConvertInput, ctx: ReadHookContext<THost>): Promise<ConvertOutcome>;
+}
+export interface FileConvertInput {
+    readonly info: Readonly<OpenFileInfo>;
+    readonly classification: Classification;
+    readonly sample: ClassificationSample;
+    /** The whole file from byte 0, capped at limits.maxConvertBytes. Call it once. */
+    bytes(): AsyncIterable<Uint8Array>;
+}
+export interface DirectoryConverter<THost = undefined> {
+    readonly id: string;
+    readonly target: "directory";
+    convert(input: DirectoryConvertInput, ctx: ReadHookContext<THost>): Promise<ConvertOutcome>;
+}
+export interface DirectoryConvertInput {
+    /** Lexical path that open() reported as a directory. */
+    readonly path: string;
+    readonly target: {
+        readonly resolvedPath: string;
+        readonly displayPath: string;
+    } | null;
+    /** Authorizes and lists the directory, up to limits.maxDirectoryEntries. Call it once. */
+    list(): Promise<ListOutcome>;
+}
+export type ConvertOutcome = {
+    readonly kind: "text";
+    readonly text: string | AsyncIterable<string>;
+    readonly mimeType: string | null;
+    readonly notes?: readonly ReadNote[];
+} | {
+    readonly kind: "media";
+    readonly parts: readonly ContentPart[];
+    readonly notes?: readonly ReadNote[];
+} | {
+    readonly kind: "refuse";
+    readonly code: string;
+    readonly note: ReadNote;
+};
+export interface ReadHook<THost = undefined> {
+    readonly id: string;
+    afterRead(outcome: ReadReport, ctx: AfterReadContext<THost>): ReadReport | Promise<ReadReport>;
+}
+export interface AfterReadContext<THost = undefined> extends ReadHookContext<THost> {
+    /** The stored record from before this read. null with no state or no record. */
+    readonly previous: ReadRecord | null;
+}
+export interface ViewBudget {
+    readonly id: string;
+    /** Cost of one clamped source line. Sync and cheap. */
+    measure(text: string): number;
+    readonly max: number;
+}

package/dist/contract/format.d.ts

@@ -0,0 +1,16 @@
+import type { ReadContext } from "./context.ts";
+import type { Digest } from "./digest.ts";
+import type { ReadLimits } from "./limits.ts";
+import type { ContentPart, ReadReport } from "./result.ts";
+export interface ReadFormatContext<THost = undefined> {
+    readonly digest: Digest | null;
+    readonly limits: Readonly<ReadLimits>;
+    /** "view" formats the body only, without notes. */
+    readonly mode: "model" | "view";
+    readonly call: ReadContext<THost>;
+}
+export interface ReadFormatter<THost = undefined> {
+    readonly id: string;
+    /** Sync and pure over the outcome. A string becomes one text part. */
+    format(outcome: ReadReport, ctx: ReadFormatContext<THost>): string | readonly ContentPart[];
+}

package/dist/contract/input.d.ts

@@ -0,0 +1,16 @@
+/** Canonical read input. A signature maps the model's parameter names to it. */
+export interface ReadInput {
+    readonly path: string;
+    /** One-based source line. Default 1. */
+    readonly offset?: number;
+    /** Maximum source lines in the view. Default and ceiling: limits.maxLines. */
+    readonly limit?: number;
+}
+/** A validated request. `offset` and `limit` are concrete. */
+export interface ReadRequest {
+    readonly path: string;
+    readonly offset: number;
+    readonly limit: number;
+    /** True when the input set `offset` or `limit`. */
+    readonly ranged: boolean;
+}

package/dist/contract/json.d.ts

@@ -0,0 +1,6 @@
+export type JsonValue = string | number | boolean | null | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};

package/dist/contract/limits.d.ts

@@ -0,0 +1,20 @@
+export interface ReadLimits {
+    /** Lines in the view. Default 2_000. */
+    readonly maxLines: number;
+    /** UTF-8 bytes of source text in the view. Default 50 KiB (51 200). */
+    readonly maxViewBytes: number;
+    /** Characters per line before clamping. Default 2_000. */
+    readonly maxCharsPerLine: number;
+    /** Bytes scanned before totals and content identity are abandoned. Default 64 MiB. */
+    readonly maxScanBytes: number;
+    /** Bytes given to classifiers. Default 8 KiB. Must not be more than maxScanBytes. */
+    readonly sampleBytes: number;
+    /** Entries in one directory listing. Default 200. */
+    readonly maxDirectoryEntries: number;
+    /** Suggested names on a miss. Default 5. */
+    readonly maxSuggestions: number;
+    /** Source bytes a converter may read. Default 64 MiB. */
+    readonly maxConvertBytes: number;
+    /** Total bytes of media parts in one result. Default 5 MiB. */
+    readonly maxMediaBytes: number;
+}

package/dist/contract/messages.d.ts

@@ -0,0 +1,110 @@
+import type { NodeKind } from "@better-fs-tools/fs";
+import type { ToolMessages } from "./base.ts";
+import type { ReadInput, ReadRequest } from "./input.ts";
+import type { TruncationReason } from "./result.ts";
+/** The stage that was running. */
+export type ReadPhase = "input" | "resolve" | "open" | "authorize" | "sampling" | "conversion" | "scan" | "verification" | "hooks";
+/**
+ * Wording for every note the read tool writes. Classifiers word their own refusals.
+ * Every message that suggests a retry gets `retry`, the text from `retry(next)`.
+ */
+export interface ReadMessageCatalog extends ToolMessages {
+    /** Prints a canonical retry the way the model must send it. Default: JSON.stringify(next). */
+    retry(next: ReadInput): string;
+    continuation(c: {
+        request: ReadRequest;
+        retry: string;
+        reason: TruncationReason;
+    }): string;
+    firstLineTooLong(c: {
+        line: number;
+        maxViewBytes: number;
+        retry: string;
+    }): string;
+    offsetPastEof(c: {
+        request: ReadRequest;
+        totalLines: number;
+        retry: string;
+    }): string;
+    offsetUnreached(c: {
+        request: ReadRequest;
+        reachedLine: number;
+        retry: string;
+    }): string;
+    lineClamped(c: {
+        lines: readonly number[];
+        total: number;
+        maxChars: number;
+    }): string;
+    /** The requested line count was over limits.maxLines, so the view uses the maximum. */
+    limitClamped(c: {
+        requested: number;
+        max: number;
+    }): string;
+    scanLimit(c: {
+        maxScanBytes: number;
+    }): string;
+    empty(c: {
+        path: string;
+    }): string;
+    notFound(c: {
+        request: ReadRequest;
+        suggestions: readonly string[];
+    }): string;
+    pathRepaired(c: {
+        from: string;
+        to: string;
+    }): string;
+    notAFile(c: {
+        request: ReadRequest;
+        kind: NodeKind;
+    }): string;
+    dangerousPath(c: {
+        request: ReadRequest;
+        detail: string | null;
+    }): string;
+    outsideAllowedRoots(c: {
+        request: ReadRequest;
+        detail: string | null;
+    }): string;
+    permissionDenied(c: {
+        request: ReadRequest;
+        detail: string | null;
+    }): string;
+    /** Used by shared authorizers such as denyPaths, for every tool. */
+    denied(c: {
+        path: string;
+        detail: string | null;
+    }): string;
+    /** `stage` "backend" means the filesystem backend refused the size before any byte was read. */
+    tooLarge(c: {
+        request: ReadRequest;
+        stage: "convert" | "media" | "backend";
+        limit: number;
+    }): string;
+    changedDuringRead(c: {
+        request: ReadRequest;
+        retry: string;
+    }): string;
+    aborted(c: {
+        phase: ReadPhase;
+    }): string;
+    invalidInput(c: {
+        detail: string;
+    }): string;
+    extensionFailed(c: {
+        request: ReadRequest;
+        extension: string;
+        phase: ReadPhase;
+    }): string;
+    ioError(c: {
+        request: ReadRequest | null;
+    }): string;
+    unsupportedBackend(c: {
+        request: ReadRequest;
+        detail: string | null;
+    }): string;
+    viewModified(c: {
+        hook: string;
+    }): string;
+}