dsh-reference-anything 0.3.0 → 0.3.2

package/lib/sources/local-agent/page.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Continuation tokens for paging backwards through a transcript.
+ *
+ * A cursor is opaque to callers but not to this file, and it carries the one
+ * thing a stateless read needs: where the previous page began. Which "where"
+ * that is depends on the branch the read took — an exact turn index when the
+ * whole file was streamed, a byte offset when only its tail was reachable — so
+ * the two are separate members rather than one nullable field.
+ *
+ * @module dsh-reference-anything/local-agent/page
+ */
+import { ReferenceAnythingError } from '../../errors.ts';
+/** Where the previous page started, and what it started in. */
+export type AgentCursor = {
+    readonly kind: 'index';
+    readonly size: number;
+    readonly index: number;
+} | {
+    readonly kind: 'offset';
+    readonly size: number;
+    readonly offset: number;
+};
+/**
+ * Encode a continuation token.
+ * @param ref - the reference id this token belongs to; a token is not portable.
+ * @param cursor - where the next page should start.
+ * @returns an opaque base64url token.
+ */
+export declare function encodeAgentCursor(ref: string, cursor: AgentCursor): string;
+/**
+ * Decode a continuation token minted for this reference.
+ *
+ * Rejects a token from another reference as firmly as a malformed one: a
+ * cursor that silently paged through a different transcript would hand the
+ * model somebody else's conversation under the label it asked for.
+ * @param value - the token as the caller supplied it.
+ * @param expectedRef - the reference id it must belong to.
+ * @returns where the next page starts.
+ */
+export declare function decodeAgentCursor(value: string, expectedRef: string): AgentCursor;
+/**
+ * Decide whether a cursor still describes the file in front of us.
+ *
+ * Deliberately not revision equality. A live agent appends to its transcript
+ * continuously, and under pure append both cursor kinds stay true: a byte
+ * offset still points at the same record and a turn index still names the same
+ * turn. Only shrinkage — a rotated, truncated, or replaced file — moves the
+ * ground under a token.
+ * @param cursor - the decoded token.
+ * @param currentSize - the transcript's size right now, in bytes.
+ * @returns whether the cursor may still be used.
+ */
+export declare function cursorStillValid(cursor: AgentCursor, currentSize: number): boolean;
+/** Raise the expiry error, so callers do not each phrase it differently. */
+export declare function cursorExpired(): ReferenceAnythingError;

package/lib/sources/local-agent/page.js

@@ -0,0 +1,83 @@
+/**
+ * Continuation tokens for paging backwards through a transcript.
+ *
+ * A cursor is opaque to callers but not to this file, and it carries the one
+ * thing a stateless read needs: where the previous page began. Which "where"
+ * that is depends on the branch the read took — an exact turn index when the
+ * whole file was streamed, a byte offset when only its tail was reachable — so
+ * the two are separate members rather than one nullable field.
+ *
+ * @module dsh-reference-anything/local-agent/page
+ */
+import { ReferenceAnythingError } from "../../errors.js";
+/** Format version, so a token minted by an older build is rejected cleanly. */
+const VERSION = 1;
+/**
+ * Encode a continuation token.
+ * @param ref - the reference id this token belongs to; a token is not portable.
+ * @param cursor - where the next page should start.
+ * @returns an opaque base64url token.
+ */
+export function encodeAgentCursor(ref, cursor) {
+    const body = cursor.kind === 'index'
+        ? { v: VERSION, ref, size: cursor.size, index: cursor.index }
+        : { v: VERSION, ref, size: cursor.size, offset: cursor.offset };
+    return Buffer.from(JSON.stringify(body)).toString('base64url');
+}
+/**
+ * Decode a continuation token minted for this reference.
+ *
+ * Rejects a token from another reference as firmly as a malformed one: a
+ * cursor that silently paged through a different transcript would hand the
+ * model somebody else's conversation under the label it asked for.
+ * @param value - the token as the caller supplied it.
+ * @param expectedRef - the reference id it must belong to.
+ * @returns where the next page starts.
+ */
+export function decodeAgentCursor(value, expectedRef) {
+    let row;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            throw new Error('not an object');
+        row = parsed;
+    }
+    catch {
+        throw malformed();
+    }
+    if (row['v'] !== VERSION || row['ref'] !== expectedRef)
+        throw malformed();
+    const size = row['size'];
+    if (!isCount(size))
+        throw malformed();
+    if (isCount(row['index']))
+        return { kind: 'index', size, index: row['index'] };
+    if (isCount(row['offset']))
+        return { kind: 'offset', size, offset: row['offset'] };
+    throw malformed();
+}
+/**
+ * Decide whether a cursor still describes the file in front of us.
+ *
+ * Deliberately not revision equality. A live agent appends to its transcript
+ * continuously, and under pure append both cursor kinds stay true: a byte
+ * offset still points at the same record and a turn index still names the same
+ * turn. Only shrinkage — a rotated, truncated, or replaced file — moves the
+ * ground under a token.
+ * @param cursor - the decoded token.
+ * @param currentSize - the transcript's size right now, in bytes.
+ * @returns whether the cursor may still be used.
+ */
+export function cursorStillValid(cursor, currentSize) {
+    return currentSize >= cursor.size;
+}
+/** Raise the expiry error, so callers do not each phrase it differently. */
+export function cursorExpired() {
+    return new ReferenceAnythingError('the transcript was truncated or replaced since this page was read, so the continuation no longer points at the same turns', 'REFERENCE_CURSOR_EXPIRED');
+}
+function isCount(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+function malformed() {
+    return new ReferenceAnythingError('transcript continuation token is malformed or belongs to another transcript', 'REFERENCE_INVALID_CURSOR');
+}

package/lib/sources/local-agent/path.d.ts

@@ -0,0 +1,8 @@
+/** Join path segments without changing an explicitly supplied path dialect. */
+export declare function joinLocalPath(base: string, ...segments: string[]): string;
+/** Normalize a path without changing an explicitly supplied path dialect. */
+export declare function normalizeLocalPath(value: string): string;
+/** Whether a path is absolute according to its explicit (or native) dialect. */
+export declare function isAbsoluteLocalPath(value: string): boolean;
+/** Whether a recorded working directory is the workspace or one of its descendants. */
+export declare function inWorkspace(cwd: string, workspace: string): boolean;

package/lib/sources/local-agent/path.js

@@ -0,0 +1,43 @@
+import path, { posix, win32 } from 'node:path';
+function explicitDialect(value) {
+    if (value.startsWith('/'))
+        return 'posix';
+    if (/^[A-Za-z]:[\\/]/.test(value) || value.startsWith('\\\\') || value.includes('\\'))
+        return 'win32';
+    return 'native';
+}
+function implementation(dialect) {
+    if (dialect === 'posix')
+        return posix;
+    if (dialect === 'win32')
+        return win32;
+    return path;
+}
+/** Join path segments without changing an explicitly supplied path dialect. */
+export function joinLocalPath(base, ...segments) {
+    return implementation(explicitDialect(base)).join(base, ...segments);
+}
+/** Normalize a path without changing an explicitly supplied path dialect. */
+export function normalizeLocalPath(value) {
+    return implementation(explicitDialect(value)).normalize(value);
+}
+/** Whether a path is absolute according to its explicit (or native) dialect. */
+export function isAbsoluteLocalPath(value) {
+    return implementation(explicitDialect(value)).isAbsolute(value);
+}
+/** Whether a recorded working directory is the workspace or one of its descendants. */
+export function inWorkspace(cwd, workspace) {
+    if (cwd === '' || workspace === '')
+        return false;
+    const cwdDialect = explicitDialect(cwd);
+    const workspaceDialect = explicitDialect(workspace);
+    if (cwdDialect !== 'native' && workspaceDialect !== 'native' && cwdDialect !== workspaceDialect)
+        return false;
+    const dialect = cwdDialect !== 'native' ? cwdDialect : workspaceDialect;
+    const paths = implementation(dialect);
+    const normalizedCwd = paths.resolve(cwd);
+    const normalizedWorkspace = paths.resolve(workspace);
+    const relative = paths.relative(normalizedWorkspace, normalizedCwd);
+    return relative === ''
+        || (!paths.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${paths.sep}`));
+}

package/lib/sources/local-agent/registry.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Which transcript formats this package can read, and where they live.
+ *
+ * One place to add a format: an adapter registered here becomes visible to
+ * discovery, to reading, and to the `@` menu without any other file learning
+ * its name.
+ *
+ * @module dsh-reference-anything/local-agent/registry
+ */
+import type { AgentAdapter, AgentKind, QueryAdapter, TranscriptAdapter } from './types.ts';
+/**
+ * Every supported adapter, in menu order.
+ *
+ * Ordered by how well the format is validated rather than alphabetically. The
+ * first two were built against real corpora on the machine this was written
+ * on — 541 Claude Code transcripts and 212 Codex rollouts — and the rest were
+ * ported from format documentation and exercised only against the fixtures in
+ * `tests/local-agent-converters.spec.ts`. That distinction is real enough to
+ * belong in the README, and the order here is what it looks like in code.
+ *
+ * The last three are database-backed and sit at the end for a second reason:
+ * they are the only ones a build without `node:sqlite` cannot read at all.
+ */
+export declare const AGENT_ADAPTERS: readonly AgentAdapter[];
+/**
+ * The formats read by walking a file, which is all but the databases.
+ *
+ * Kept as a narrowed array rather than filtered at each use so the discovery
+ * walk and the read path agree on which seam an adapter answers to.
+ */
+export declare const FILE_ADAPTERS: readonly TranscriptAdapter[];
+/** The formats read by querying a database. */
+export declare const QUERY_ADAPTERS: readonly QueryAdapter[];
+/** Whether a format is read by querying a database rather than by walking a file. */
+export declare function isQueryKind(kind: string): boolean;
+/** Every supported {@link AgentKind}, in the same order. */
+export declare const AGENT_KINDS: readonly AgentKind[];
+/**
+ * The format an extra root is assumed to hold when its entry does not say.
+ *
+ * Named rather than indexed off {@link AGENT_KINDS} so the choice reads as a
+ * choice — the best-validated format is the safe thing to guess.
+ */
+export declare const DEFAULT_AGENT_KIND: AgentKind;
+/**
+ * Find the adapter for a format.
+ * @param kind - a format name, which may have come from config or from a reference id.
+ * @returns the adapter, or undefined when nothing reads that format.
+ */
+export declare function adapterFor(kind: string): AgentAdapter | undefined;
+/**
+ * Whether a string names a supported format.
+ * @param kind - the candidate name.
+ * @returns whether {@link adapterFor} would resolve it.
+ */
+export declare function isAgentKind(kind: string): kind is AgentKind;
+/**
+ * Resolve a configured root to an absolute path.
+ *
+ * Roots are written as portable `~/`-prefixed strings rather than absolute
+ * ones so a profile can be shared between machines and users. Expansion is
+ * plain string work on purpose: an external plugin overlay is not permitted to
+ * evaluate code, so a root must never need any.
+ * @param root - a configured root, `~`-relative or absolute.
+ * @param home - the user's home directory.
+ * @returns the absolute path, or undefined when the root is empty or relative.
+ */
+export declare function expandRoot(root: string, home: string): string | undefined;

package/lib/sources/local-agent/registry.js

@@ -0,0 +1,116 @@
+/**
+ * Which transcript formats this package can read, and where they live.
+ *
+ * One place to add a format: an adapter registered here becomes visible to
+ * discovery, to reading, and to the `@` menu without any other file learning
+ * its name.
+ *
+ * @module dsh-reference-anything/local-agent/registry
+ */
+import { claudeCodeAdapter } from "./adapters/claude-code.js";
+import { codexAdapter } from "./adapters/codex.js";
+import { cursorAdapter } from "./adapters/cursor.js";
+import { geminiCliAdapter } from "./adapters/gemini-cli.js";
+import { grokbuildAdapter } from "./adapters/grokbuild.js";
+import { hermesAdapter } from "./adapters/hermes.js";
+import { kimiAdapter } from "./adapters/kimi.js";
+import { mimocodeAdapter, opencodeAdapter } from "./adapters/opencode.js";
+import { openclawAdapter } from "./adapters/openclaw.js";
+import { piAdapter } from "./adapters/pi.js";
+import { qoderAdapter } from "./adapters/qoder.js";
+import { reasonixAdapter } from "./adapters/reasonix.js";
+import { zcodeAdapter } from "./adapters/zcode.js";
+import { isQueryAdapter } from "./types.js";
+import { isAbsoluteLocalPath, joinLocalPath, normalizeLocalPath } from "./path.js";
+/**
+ * Every supported adapter, in menu order.
+ *
+ * Ordered by how well the format is validated rather than alphabetically. The
+ * first two were built against real corpora on the machine this was written
+ * on — 541 Claude Code transcripts and 212 Codex rollouts — and the rest were
+ * ported from format documentation and exercised only against the fixtures in
+ * `tests/local-agent-converters.spec.ts`. That distinction is real enough to
+ * belong in the README, and the order here is what it looks like in code.
+ *
+ * The last three are database-backed and sit at the end for a second reason:
+ * they are the only ones a build without `node:sqlite` cannot read at all.
+ */
+export const AGENT_ADAPTERS = [
+    claudeCodeAdapter,
+    codexAdapter,
+    cursorAdapter,
+    qoderAdapter,
+    reasonixAdapter,
+    openclawAdapter,
+    kimiAdapter,
+    grokbuildAdapter,
+    hermesAdapter,
+    geminiCliAdapter,
+    piAdapter,
+    opencodeAdapter,
+    mimocodeAdapter,
+    zcodeAdapter,
+];
+/**
+ * The formats read by walking a file, which is all but the databases.
+ *
+ * Kept as a narrowed array rather than filtered at each use so the discovery
+ * walk and the read path agree on which seam an adapter answers to.
+ */
+export const FILE_ADAPTERS = AGENT_ADAPTERS.filter((adapter) => !isQueryAdapter(adapter));
+/** The formats read by querying a database. */
+export const QUERY_ADAPTERS = AGENT_ADAPTERS.filter(isQueryAdapter);
+/** Whether a format is read by querying a database rather than by walking a file. */
+export function isQueryKind(kind) {
+    const adapter = BY_KIND.get(kind);
+    return adapter !== undefined && isQueryAdapter(adapter);
+}
+/** Every supported {@link AgentKind}, in the same order. */
+export const AGENT_KINDS = AGENT_ADAPTERS.map(adapter => adapter.kind);
+/**
+ * The format an extra root is assumed to hold when its entry does not say.
+ *
+ * Named rather than indexed off {@link AGENT_KINDS} so the choice reads as a
+ * choice — the best-validated format is the safe thing to guess.
+ */
+export const DEFAULT_AGENT_KIND = claudeCodeAdapter.kind;
+const BY_KIND = new Map(AGENT_ADAPTERS.map(adapter => [adapter.kind, adapter]));
+/**
+ * Find the adapter for a format.
+ * @param kind - a format name, which may have come from config or from a reference id.
+ * @returns the adapter, or undefined when nothing reads that format.
+ */
+export function adapterFor(kind) {
+    return BY_KIND.get(kind);
+}
+/**
+ * Whether a string names a supported format.
+ * @param kind - the candidate name.
+ * @returns whether {@link adapterFor} would resolve it.
+ */
+export function isAgentKind(kind) {
+    return BY_KIND.has(kind);
+}
+/**
+ * Resolve a configured root to an absolute path.
+ *
+ * Roots are written as portable `~/`-prefixed strings rather than absolute
+ * ones so a profile can be shared between machines and users. Expansion is
+ * plain string work on purpose: an external plugin overlay is not permitted to
+ * evaluate code, so a root must never need any.
+ * @param root - a configured root, `~`-relative or absolute.
+ * @param home - the user's home directory.
+ * @returns the absolute path, or undefined when the root is empty or relative.
+ */
+export function expandRoot(root, home) {
+    const trimmed = root.trim();
+    if (trimmed === '')
+        return undefined;
+    if (trimmed === '~')
+        return home;
+    if (trimmed.startsWith('~/') || trimmed.startsWith('~\\'))
+        return normalizeLocalPath(joinLocalPath(home, trimmed.slice(2)));
+    // A relative root would resolve against whatever directory the harness
+    // happened to launch in, which is not a boundary anyone chose.
+    return isAbsoluteLocalPath(trimmed) ? normalizeLocalPath(trimmed) : undefined;
+}

package/lib/sources/local-agent/scan.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Filesystem access for local agent transcripts.
+ *
+ * Everything that touches the disk lives here, so the adapters stay pure and
+ * testable against inline fixtures. Two facts about the corpus shape every
+ * function below, both measured rather than assumed:
+ *
+ * - **Transcripts are large.** 541 Claude files totalling 734 MB and 212 Codex
+ *   rollouts totalling 2.24 GB sit on the machine this was written against, the
+ *   largest single rollout being 192 MB. Nothing here may read a whole file.
+ * - **Lines are large and wildly uneven.** In one 21 MB rollout: p50 = 812 B,
+ *   p90 = 14 KB, p99 = 1.4 MB, max = 4.0 MB. A fixed 32 KiB probe window
+ *   recovers exactly one complete line there — which is why probes escalate by
+ *   *lines wanted* under a byte ceiling, and why the streaming pass budgets in
+ *   bytes rather than lines.
+ *
+ * @module dsh-reference-anything/local-agent/scan
+ */
+import type { AgentAdapter, AgentKind, ConvertOptions, ParsedTurn, QueryAdapter, SessionTurns, TranscriptAdapter, TranscriptSession } from './types.ts';
+/** One directory to search, and the agent whose transcripts live in it. */
+export interface ScanRoot {
+    readonly kind: AgentKind;
+    /** Absolute path; already expanded from any `~/` prefix. */
+    readonly path: string;
+}
+/** One transcript found on disk, described without reading a byte of it. */
+export interface TranscriptDescriptor {
+    readonly kind: AgentKind;
+    /** Absolute path, for reading. */
+    readonly path: string;
+    /**
+     * Path relative to its root — the stable half of the reference id.
+     *
+     * For a database-backed format this is `<database>#<session id>`, because one
+     * file holds many conversations and a reference has to name which. The `#`
+     * costs nothing elsewhere: it is not a path separator, so the id round-trip
+     * and the bookmark key are unchanged, and a real filename containing one
+     * still belongs to a file-backed format that never splits on it.
+     */
+    readonly relPath: string;
+    readonly mtimeMs: number;
+    readonly size: number;
+    /**
+     * The session row, for a database-backed format only.
+     *
+     * A `session` row already carries the title, working directory, and times a
+     * probe would otherwise have to read a file to find, so a query descriptor
+     * arrives complete and never needs backfilling.
+     */
+    readonly session?: TranscriptSession;
+}
+/** Separates a database from the session inside it, in a reference id. */
+export declare const SESSION_SEPARATOR = "#";
+/** How far a probe may read before giving up on a transcript's metadata. */
+export interface ProbeLimits {
+    readonly headLines: number;
+    readonly tailLines: number;
+    readonly maxProbeBytes: number;
+}
+/** Complete records recovered from the two ends of a transcript. */
+export interface TranscriptEnds {
+    readonly headLines: readonly string[];
+    readonly tailLines: readonly string[];
+    /**
+     * Whether `headLines` is the whole file rather than a window onto its start.
+     *
+     * Only true when the first probe window already reached EOF, which is what
+     * lets a caller conclude something from an *absence*: a transcript that folds
+     * to no turns is only known to hold no conversation if every one of its
+     * records was seen. Without this flag a short probe of a long file looks
+     * identical to a complete probe of an aborted one.
+     */
+    readonly complete: boolean;
+}
+/** How much of a transcript one read may touch. */
+export interface ReadLimits {
+    /** Total bytes a single read may consume before it falls back to the tail. */
+    readonly maxScanBytes: number;
+    /** Longest single line that will be materialized; longer ones are skipped. */
+    readonly maxLineBytes: number;
+}
+/** Which turns to materialize. */
+export interface TurnRequest {
+    readonly limit: number;
+    /** Exclusive upper bound in turn indices; absent means the newest turns. */
+    readonly before?: number;
+    /** Tail-anchored paging: only bytes below this offset may be read. */
+    readonly beforeOffset?: number;
+}
+/** The turns one read produced, and where they sit in the transcript. */
+export interface TurnPage {
+    readonly items: readonly ParsedTurn[];
+    /** Index of `items[0]`; always 0 when the read was tail-anchored. */
+    readonly startIndex: number;
+    /** Exact count, or undefined when the read never saw the beginning. */
+    readonly totalTurns?: number;
+    readonly hasOlder: boolean;
+    /** Whether the transcript records a compaction, so earlier turns are gone. */
+    readonly compacted: boolean;
+    /** Whether the read was tail-anchored and so could not see the beginning. */
+    readonly anchored: boolean;
+    /** Byte offset the first returned turn began at; only set when anchored. */
+    readonly startOffset?: number;
+}
+/**
+ * Find every transcript under the given roots.
+ *
+ * Reads directory entries and stats only — no file contents — because this runs
+ * behind a keystroke debounce. A root that does not exist is an ordinary state
+ * (that agent is not installed) and is skipped rather than raised.
+ * @param roots - directories to search, each tagged with its agent.
+ * @param adapters - adapters by kind, used to test filenames.
+ * @param maxTranscripts - most descriptors to return, newest first.
+ * @param signal - cancellation from the caller.
+ * @returns descriptors sorted newest-modified first, at most `maxTranscripts`.
+ */
+export declare function listTranscripts(roots: readonly ScanRoot[], adapters: ReadonlyMap<AgentKind, AgentAdapter>, maxTranscripts: number, signal?: AbortSignal): Promise<TranscriptDescriptor[]>;
+/**
+ * Look up the row that describes one conversation.
+ *
+ * A read may arrive without a listing having preceded it — the model can hold a
+ * reference id across turns, and `locate()` resolves a path rather than
+ * replaying discovery — so this is what gives a database-backed snapshot its
+ * title, working directory, and times.
+ * @param path - absolute path to the database.
+ * @param adapter - the adapter that knows this schema.
+ * @param sessionId - which conversation to describe.
+ * @param signal - cancellation from the caller.
+ * @returns the session row, or undefined when the database or the row is unreadable.
+ */
+export declare function readSessionInfo(path: string, adapter: QueryAdapter, sessionId: string, signal?: AbortSignal): Promise<TranscriptSession | undefined>;
+/**
+ * Read one conversation out of a database.
+ * @param path - absolute path to the database.
+ * @param adapter - the adapter that knows this schema.
+ * @param sessionId - which conversation to fold.
+ * @param options - projection settings.
+ * @param maxRecords - most message rows to materialize, counted from the end.
+ * @param signal - cancellation from the caller.
+ * @returns the folded turns, oldest first.
+ */
+export declare function readSessionTurns(path: string, adapter: QueryAdapter, sessionId: string, options: ConvertOptions, maxRecords: number, signal?: AbortSignal): Promise<SessionTurns>;
+/**
+ * Recover complete records from both ends of a transcript.
+ *
+ * Escalates through {@link PROBE_STEPS} until enough complete lines are in hand
+ * or the byte ceiling is reached, because a fixed window cannot serve a corpus
+ * whose p99 line is 1.4 MB. Giving up returns whatever was recovered rather
+ * than throwing: a transcript with no readable metadata still lists, under a
+ * fallback label.
+ * @param path - absolute path to the transcript.
+ * @param size - its size in bytes, from a prior stat.
+ * @param limits - how many lines are wanted and how far to read for them.
+ * @param signal - cancellation from the caller.
+ * @returns the complete records found at each end.
+ */
+export declare function probeEnds(path: string, size: number, limits: ProbeLimits, signal?: AbortSignal): Promise<TranscriptEnds>;
+/**
+ * Read one window of turns from a transcript.
+ *
+ * Takes one of two branches. Under `maxScanBytes` it streams the whole file
+ * once, so `startIndex` and `totalTurns` are exact. Over it — the 192 MB
+ * rollout — it walks backwards from the end far enough to fill the window,
+ * which is honest but cannot see the beginning: `totalTurns` is then undefined
+ * and the caller must report the snapshot as partial.
+ * @param path - absolute path to the transcript.
+ * @param size - its size in bytes, from a prior stat.
+ * @param adapter - the format's adapter.
+ * @param options - projection settings.
+ * @param request - which turns to return.
+ * @param limits - how much of the file this read may touch.
+ * @param signal - cancellation from the caller.
+ * @returns the turns and their position in the transcript.
+ */
+export declare function readTurns(path: string, size: number, adapter: TranscriptAdapter, options: ConvertOptions, request: TurnRequest, limits: ReadLimits, signal?: AbortSignal): Promise<TurnPage>;