@1agents/session-reader 0.1.1

package/dist/src/resolver.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { antigravityAdapter } from './parsers/antigravity.js';
+import { claudeAdapter } from './parsers/claude.js';
+import { codexAdapter } from './parsers/codex.js';
+import { canonicalizePath, isInside, slugifyWorkspace } from './util/paths.js';
+export const adapters = [antigravityAdapter, claudeAdapter, codexAdapter];
+/** How many files we are willing to open when nothing narrows the search. */
+const DEFAULT_SCAN = 60;
+/** A workspace filter rejects most candidates, so it needs a wider net. */
+const WORKSPACE_SCAN = 600;
+/** Accepts `24h`, `90m`, `7d`, `2026-09-01` or a Date. */
+export function parseSince(since) {
+    if (!since)
+        return undefined;
+    if (since instanceof Date)
+        return since.getTime();
+    const relative = /^(\d+)\s*([hdmw])$/i.exec(since.trim());
+    if (relative) {
+        const amount = Number(relative[1]);
+        const unit = relative[2].toLowerCase();
+        const ms = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 }[unit] ?? 0;
+        return Date.now() - amount * ms;
+    }
+    const parsed = Date.parse(since);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function matchesWorkspace(ref, workspace) {
+    if (!ref.workspace)
+        return false;
+    return isInside(workspace, ref.workspace);
+}
+/**
+ * Claude stores sessions under a slugified cwd, so the directory name alone
+ * tells us whether a file can possibly belong to the workspace.
+ */
+function couldBelong(candidate, provider, workspace) {
+    if (provider !== 'claude')
+        return true;
+    const slug = slugifyWorkspace(workspace);
+    const dir = path.basename(path.dirname(candidate.path));
+    return dir === slug || dir.startsWith(`${slug}-`);
+}
+/** Discovery that keeps the adapter handle, so callers can parse without a second scan. */
+export async function listResolvedSessions(options = {}) {
+    const limit = options.limit ?? 20;
+    const workspace = options.workspace ? canonicalizePath(options.workspace) : undefined;
+    const sinceMs = parseSince(options.since);
+    const found = [];
+    for (const adapter of adapters) {
+        if (options.provider && adapter.provider !== options.provider)
+            continue;
+        const candidates = await adapter.listCandidates();
+        let scanned = 0;
+        const budget = options.scan ?? (workspace ? WORKSPACE_SCAN : DEFAULT_SCAN);
+        for (const candidate of candidates) {
+            if (sinceMs && candidate.mtimeMs < sinceMs)
+                break; // candidates are newest first
+            if (scanned >= budget)
+                break;
+            if (workspace && !couldBelong(candidate, adapter.provider, workspace))
+                continue;
+            scanned++;
+            const ref = await adapter.scanRef(candidate).catch(() => undefined);
+            if (!ref)
+                continue;
+            if (workspace && !matchesWorkspace(ref, workspace))
+                continue;
+            found.push({ ref, adapter, candidate });
+        }
+    }
+    return found
+        .sort((a, b) => Date.parse(b.ref.updatedAt ?? '') - Date.parse(a.ref.updatedAt ?? ''))
+        .slice(0, limit);
+}
+export async function listRecentSessions(options = {}) {
+    return (await listResolvedSessions(options)).map((session) => session.ref);
+}
+export async function findSessionsByWorkspace(workspacePath, options = {}) {
+    return listRecentSessions({ ...options, limit: options.limit ?? 50, workspace: workspacePath });
+}
+export async function findResolvedByWorkspace(workspacePath, options = {}) {
+    return listResolvedSessions({ ...options, limit: options.limit ?? 50, workspace: workspacePath });
+}
+/** Locates a session by full id, id prefix, or native file path. */
+export async function resolveSession(sessionId) {
+    const asPath = sessionId.includes('/') ? canonicalizePath(sessionId) : undefined;
+    const needle = sessionId.toLowerCase();
+    let prefixHit;
+    for (const adapter of adapters) {
+        for (const candidate of await adapter.listCandidates()) {
+            if (asPath ? candidate.path === asPath : candidate.id.toLowerCase() === needle) {
+                return { ref: await adapter.scanRef(candidate), adapter, candidate };
+            }
+            if (!asPath && !prefixHit && needle.length >= 6 && candidate.id.toLowerCase().startsWith(needle)) {
+                prefixHit = { adapter, candidate };
+            }
+        }
+    }
+    if (!prefixHit)
+        return undefined;
+    return { ...prefixHit, ref: await prefixHit.adapter.scanRef(prefixHit.candidate) };
+}
+export async function parseSession(sessionId) {
+    const resolved = await resolveSession(sessionId);
+    if (!resolved)
+        throw new Error(`session not found: ${sessionId}`);
+    return resolved.adapter.parse(resolved.candidate);
+}
+/**
+ * The one seam every command loads sessions through. Whether the events come
+ * from the index or straight off disk, the object handed back is the same, so
+ * `buildOverview` / `fileLedger` / `summarizeTurns` never learn about caching.
+ */
+export async function loadSession(sessionId, options = {}) {
+    if (options.useIndex === false || process.env.SESSION_READER_NO_INDEX === '1') {
+        return parseSession(sessionId);
+    }
+    const { openStore } = await import('./store/db.js');
+    const { findSessionRow } = await import('./store/read.js');
+    const { indexSession } = await import('./store/indexer.js');
+    const db = await openStore();
+    // A session the index already knows can be re-checked with a single stat,
+    // instead of walking every provider directory again.
+    const row = findSessionRow(db, sessionId);
+    const handle = (row ? await handleFromPath(row.provider, row.native_id, row.source_path) : undefined)
+        ?? (await resolveSession(sessionId));
+    if (!handle)
+        throw new Error(`session not found: ${sessionId}`);
+    const result = await indexSession(db, handle, { ...(options.force ? { force: true } : {}) });
+    return result.session;
+}
+/** Rebuilds an adapter handle from an indexed row without a directory scan. */
+async function handleFromPath(provider, nativeId, sourcePath) {
+    const adapter = adapters.find((item) => item.provider === provider);
+    if (!adapter)
+        return undefined;
+    const stat = await fs.stat(sourcePath).catch(() => undefined);
+    if (!stat)
+        return undefined;
+    return {
+        adapter,
+        candidate: { id: nativeId, path: sourcePath, mtimeMs: stat.mtimeMs, sizeBytes: stat.size },
+    };
+}

package/dist/src/search.d.ts

@@ -0,0 +1,59 @@
+import { type ListOptions } from './resolver.js';
+import type { SessionRef, TurnKind } from './types.js';
+export interface SearchOptions extends ListOptions {
+    /** Bypass the index and parse every candidate from disk. */
+    useIndex?: boolean;
+    /** Restrict to these turn kinds; defaults to all of them. */
+    kinds?: TurnKind[];
+    /** Treat the query as a regular expression instead of a literal. */
+    regex?: boolean;
+    caseSensitive?: boolean;
+    /** Characters of context kept around each match. */
+    context?: number;
+    /** Matches recorded per session before scanning moves on. */
+    maxPerSession?: number;
+}
+export interface SearchMatch {
+    index: number;
+    kind: TurnKind;
+    toolName?: string;
+    timestamp?: string;
+    excerpt: string;
+}
+export interface SearchHit {
+    session: SessionRef;
+    matches: SearchMatch[];
+    totalMatches: number;
+}
+/**
+ * A substring that every string matching `source` must contain, or `undefined`
+ * when no such substring can be proven.
+ *
+ * Deliberately timid: alternation or groups anywhere and it gives up. A
+ * prefilter that is merely usually right would hand back "searched everything"
+ * answers that quietly missed rows — the exact failure this store exists to
+ * remove — so "no literal" is always the safe reply.
+ */
+export declare function mandatoryLiteral(source: string): string | undefined;
+export interface QueryPlan {
+    literal?: string;
+    fold?: boolean;
+}
+/**
+ * Turns a query into an optional SQL prefilter.
+ *
+ * Case folding has to agree with what the matcher does. A `gi` regex without
+ * the `u` flag folds ASCII only — exactly what SQLite's `lower()` does — so an
+ * ASCII literal can be folded on both sides. Anything else falls back to the
+ * longest run of characters that have no case at all, where folding is a no-op
+ * either way.
+ */
+export declare function planQuery(query: string, options?: SearchOptions): QueryPlan;
+/**
+ * Full-text search across sessions.
+ *
+ * Scope is never silently trimmed: every session passing `workspace` /
+ * `since` / `provider` is searched, and `limit` only caps how many of the
+ * resulting hits come back.
+ */
+export declare function searchSessions(query: string, options?: SearchOptions): Promise<SearchHit[]>;

package/dist/src/search.js

@@ -0,0 +1,257 @@
+import { adapters, listResolvedSessions, parseSince } from './resolver.js';
+import { canonicalizePath, isInside } from './util/paths.js';
+const DEFAULT_CONTEXT = 100;
+const DEFAULT_MAX_PER_SESSION = 5;
+const HARD_CAP = 200;
+function buildPattern(query, options) {
+    const source = options.regex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(source, options.caseSensitive ? 'g' : 'gi');
+}
+/** Everything in a turn that is worth matching against, as one flat string. */
+function haystack(turn) {
+    const args = turn.toolArgs ? JSON.stringify(turn.toolArgs) : '';
+    return [turn.text, turn.toolResult, args].filter(Boolean).join('\n');
+}
+/** Slices around the match first, then collapses whitespace, so offsets stay valid. */
+function excerpt(body, at, length, context) {
+    const start = Math.max(0, at - context);
+    const end = Math.min(body.length, at + length + context);
+    const slice = body.slice(start, end).replace(/\s+/g, ' ').trim();
+    return `${start > 0 ? '…' : ''}${slice}${end < body.length ? '…' : ''}`;
+}
+// ---------------------------------------------------------------------------
+// Query planning
+// ---------------------------------------------------------------------------
+/** Escapes that stand for a class of characters rather than one literal one. */
+const CLASS_ESCAPES = new Set('dDwWsSbBnrtfv0xucpPk'.split(''));
+/**
+ * A substring that every string matching `source` must contain, or `undefined`
+ * when no such substring can be proven.
+ *
+ * Deliberately timid: alternation or groups anywhere and it gives up. A
+ * prefilter that is merely usually right would hand back "searched everything"
+ * answers that quietly missed rows — the exact failure this store exists to
+ * remove — so "no literal" is always the safe reply.
+ */
+export function mandatoryLiteral(source) {
+    if (/[|()]/.test(source))
+        return undefined;
+    let best = '';
+    let run = '';
+    const flush = () => {
+        if (run.length > best.length)
+            best = run;
+        run = '';
+    };
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === '\\') {
+            const next = source[++i];
+            if (next === undefined)
+                break;
+            if (CLASS_ESCAPES.has(next))
+                flush();
+            else
+                run += next; // an escaped literal character
+            continue;
+        }
+        if (ch === '[') {
+            flush();
+            while (i < source.length && source[i] !== ']')
+                i += source[i] === '\\' ? 2 : 1;
+            continue;
+        }
+        // `?`, `*` and `{…}` can make the preceding character disappear, so it
+        // stops being mandatory. `+` keeps it (one occurrence at least).
+        if (ch === '?' || ch === '*') {
+            run = run.slice(0, -1);
+            flush();
+            continue;
+        }
+        if (ch === '{') {
+            run = run.slice(0, -1);
+            flush();
+            while (i < source.length && source[i] !== '}')
+                i++;
+            continue;
+        }
+        if (ch === '+' || ch === '.' || ch === '^' || ch === '$') {
+            flush();
+            continue;
+        }
+        run += ch;
+    }
+    flush();
+    return best.length >= 2 ? best : undefined;
+}
+/** True when a character is unaffected by case folding (CJK, digits, punctuation). */
+function caseless(ch) {
+    return ch.toLowerCase() === ch && ch.toUpperCase() === ch;
+}
+function longestCaselessRun(value) {
+    let best = '';
+    let run = '';
+    for (const ch of value) {
+        if (caseless(ch)) {
+            run += ch;
+            if (run.length > best.length)
+                best = run;
+        }
+        else {
+            run = '';
+        }
+    }
+    return best;
+}
+/**
+ * Turns a query into an optional SQL prefilter.
+ *
+ * Case folding has to agree with what the matcher does. A `gi` regex without
+ * the `u` flag folds ASCII only — exactly what SQLite's `lower()` does — so an
+ * ASCII literal can be folded on both sides. Anything else falls back to the
+ * longest run of characters that have no case at all, where folding is a no-op
+ * either way.
+ */
+export function planQuery(query, options = {}) {
+    const raw = options.regex ? mandatoryLiteral(query) : query;
+    // A literal spanning a newline could straddle two columns, which the
+    // per-column prefilter would miss.
+    if (!raw || raw.length < 2 || raw.includes('\n'))
+        return {};
+    if (options.caseSensitive)
+        return { literal: raw };
+    // eslint-disable-next-line no-control-regex
+    if (/^[\x00-\x7F]*$/.test(raw))
+        return { literal: raw.toLowerCase(), fold: true };
+    const run = longestCaselessRun(raw);
+    return run.length >= 2 ? { literal: run } : {};
+}
+function accumulate(hits, sessionId, candidate, pattern, context, maxPerSession) {
+    if (!candidate.body)
+        return;
+    pattern.lastIndex = 0;
+    const found = pattern.exec(candidate.body);
+    if (!found)
+        return;
+    const bucket = hits.get(sessionId) ?? { matches: [], totalMatches: 0 };
+    bucket.totalMatches++;
+    if (bucket.matches.length < Math.min(maxPerSession, HARD_CAP)) {
+        bucket.matches.push({
+            index: candidate.index,
+            kind: candidate.kind,
+            ...(candidate.toolName ? { toolName: candidate.toolName } : {}),
+            ...(candidate.timestamp ? { timestamp: candidate.timestamp } : {}),
+            excerpt: excerpt(candidate.body, found.index, found[0].length, context),
+        });
+    }
+    hits.set(sessionId, bucket);
+}
+/**
+ * Full-text search across sessions.
+ *
+ * Scope is never silently trimmed: every session passing `workspace` /
+ * `since` / `provider` is searched, and `limit` only caps how many of the
+ * resulting hits come back.
+ */
+export async function searchSessions(query, options = {}) {
+    if (!query.trim())
+        throw new Error('search query must not be empty');
+    const pattern = buildPattern(query, options);
+    const context = options.context ?? DEFAULT_CONTEXT;
+    const maxPerSession = options.maxPerSession ?? DEFAULT_MAX_PER_SESSION;
+    const direct = options.useIndex === false || process.env.SESSION_READER_NO_INDEX === '1';
+    const hits = direct
+        ? await searchByParsing(query, options, pattern, context, maxPerSession)
+        : await searchByIndex(query, options, pattern, context, maxPerSession);
+    return hits
+        .sort((a, b) => Date.parse(b.session.updatedAt ?? '') - Date.parse(a.session.updatedAt ?? ''))
+        .slice(0, options.limit ?? hits.length);
+}
+/** The oracle: parses every candidate from disk, touching no stored state. */
+async function searchByParsing(_query, options, pattern, context, maxPerSession) {
+    const kinds = options.kinds?.length ? new Set(options.kinds) : undefined;
+    const hits = [];
+    const handles = await listResolvedSessions({
+        ...options,
+        limit: Number.POSITIVE_INFINITY,
+        scan: Number.POSITIVE_INFINITY,
+    });
+    for (const handle of handles) {
+        const session = await handle.adapter.parse(handle.candidate).catch(() => undefined);
+        if (!session)
+            continue;
+        const bucket = new Map();
+        for (const turn of session.turns) {
+            if (kinds && !kinds.has(turn.kind))
+                continue;
+            accumulate(bucket, session.ref.id, {
+                index: turn.index,
+                kind: turn.kind,
+                ...(turn.toolName ? { toolName: turn.toolName } : {}),
+                ...(turn.timestamp ? { timestamp: turn.timestamp } : {}),
+                body: haystack(turn),
+            }, pattern, context, maxPerSession);
+        }
+        const found = bucket.get(session.ref.id);
+        if (found)
+            hits.push({ session: session.ref, ...found });
+    }
+    return hits;
+}
+/**
+ * Index path: candidate rows come from SQL, the verdict stays with the regex.
+ *
+ * Sessions are never materialized — rebuilding 622 of them into objects cost
+ * more than every other part of a search put together.
+ */
+async function searchByIndex(query, options, pattern, context, maxPerSession) {
+    const { openStore } = await import('./store/db.js');
+    const { refreshSession } = await import('./store/indexer.js');
+    const { searchRows } = await import('./store/rows.js');
+    const { refOf } = await import('./store/read.js');
+    const db = await openStore();
+    const sinceMs = parseSince(options.since);
+    const ids = [];
+    for (const adapter of adapters) {
+        if (options.provider && adapter.provider !== options.provider)
+            continue;
+        for (const candidate of await adapter.listCandidates()) {
+            if (sinceMs && candidate.mtimeMs < sinceMs)
+                break; // newest first
+            const result = await refreshSession(db, { adapter, candidate }, { edges: false }).catch(() => undefined);
+            if (result)
+                ids.push(result.id);
+        }
+    }
+    const plan = planQuery(query, options);
+    const workspace = options.workspace ? canonicalizePath(options.workspace) : undefined;
+    const buckets = new Map();
+    for (const row of searchRows(db, {
+        ids,
+        ...(workspace ? { workspace } : {}),
+        ...(options.kinds?.length ? { kinds: options.kinds } : {}),
+        ...(plan.literal ? { literal: plan.literal } : {}),
+        ...(plan.fold ? { fold: true } : {}),
+    })) {
+        const args = row.tool_args_json ?? '';
+        accumulate(buckets, row.session_id, {
+            index: row.idx,
+            kind: row.kind,
+            ...(row.tool_name ? { toolName: row.tool_name } : {}),
+            ...(row.ts ? { timestamp: row.ts } : {}),
+            // Rebuilt exactly as `haystack` does, so an excerpt cannot shift.
+            body: [row.text ?? undefined, row.tool_result ?? undefined, args].filter(Boolean).join('\n'),
+        }, pattern, context, maxPerSession);
+    }
+    const hits = [];
+    for (const [id, bucket] of buckets) {
+        const row = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+        if (!row)
+            continue;
+        const ref = refOf(row);
+        if (workspace && !isInside(workspace, ref.workspace ?? ''))
+            continue;
+        hits.push({ session: ref, ...bucket });
+    }
+    return hits;
+}

package/dist/src/store/db.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseSync } from 'node:sqlite';
+/** Where the index lives. `SESSION_READER_DB` overrides it (tests, CI). */
+export declare function defaultDbPath(): string;
+/**
+ * Opens (and migrates) the index. The handle is cached per path so a single
+ * CLI run never opens the file twice.
+ */
+export declare function openStore(dbPath?: string): Promise<DatabaseSync>;
+/** Test hook — forgets the cached handle so a new path can be opened. */
+export declare function resetStoreCache(): void;

package/dist/src/store/db.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { DDL, SCHEMA_VERSION } from './schema.js';
+/** Where the index lives. `SESSION_READER_DB` overrides it (tests, CI). */
+export function defaultDbPath() {
+    const override = process.env.SESSION_READER_DB;
+    if (override)
+        return override;
+    return path.join(os.homedir(), '.1agents', 'session-reader', 'index.db');
+}
+/**
+ * `node:sqlite` is still flagged experimental and prints a warning on load.
+ * Filtering just that one message keeps every other warning intact — far less
+ * rude than `removeAllListeners('warning')`.
+ */
+async function importSqlite() {
+    const original = process.emitWarning;
+    process.emitWarning = ((warning, ...rest) => {
+        const text = typeof warning === 'string' ? warning : (warning?.message ?? '');
+        if (text.includes('SQLite is an experimental feature'))
+            return;
+        return original.call(process, warning, ...rest);
+    });
+    try {
+        return await import('node:sqlite');
+    }
+    finally {
+        process.emitWarning = original;
+    }
+}
+let cached;
+let cachedPath;
+/**
+ * Opens (and migrates) the index. The handle is cached per path so a single
+ * CLI run never opens the file twice.
+ */
+export async function openStore(dbPath = defaultDbPath()) {
+    if (cached && cachedPath === dbPath)
+        return cached;
+    const { DatabaseSync: Sqlite } = await importSqlite();
+    if (dbPath !== ':memory:')
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    let db = new Sqlite(dbPath);
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA synchronous = NORMAL');
+    db.exec('PRAGMA busy_timeout = 5000');
+    if (schemaVersionOf(db) !== SCHEMA_VERSION) {
+        db = rebuild(db, Sqlite, dbPath);
+    }
+    db.exec(DDL);
+    db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)').run('schema_version', String(SCHEMA_VERSION));
+    cached = db;
+    cachedPath = dbPath;
+    return db;
+}
+function schemaVersionOf(db) {
+    try {
+        const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+        return row?.value ? Number(row.value) : undefined;
+    }
+    catch {
+        return undefined; // no meta table yet — a fresh file
+    }
+}
+/**
+ * A DDL change invalidates every derived row, and L0 can rebuild all of it, so
+ * starting from an empty file beats writing migration code for a cache.
+ */
+function rebuild(db, Sqlite, dbPath) {
+    const hadTables = db.prepare("SELECT count(*) AS c FROM sqlite_master WHERE type = 'table'").get().c > 0;
+    if (!hadTables)
+        return db;
+    db.close();
+    if (dbPath !== ':memory:') {
+        for (const suffix of ['', '-wal', '-shm'])
+            fs.rmSync(`${dbPath}${suffix}`, { force: true });
+    }
+    const fresh = new Sqlite(dbPath);
+    fresh.exec('PRAGMA journal_mode = WAL');
+    fresh.exec('PRAGMA synchronous = NORMAL');
+    fresh.exec('PRAGMA busy_timeout = 5000');
+    return fresh;
+}
+/** Test hook — forgets the cached handle so a new path can be opened. */
+export function resetStoreCache() {
+    cached = undefined;
+    cachedPath = undefined;
+}

package/dist/src/store/edges.d.ts

@@ -0,0 +1,46 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { NormalizedSession, TurnEvent } from '../types.js';
+/**
+ * How one session relates to another. Only the two we can prove today are
+ * emitted; the rest are reserved so the vocabulary does not get invented
+ * twice, and are never guessed from coincidence.
+ */
+export type EdgeRelation = 'references' | 'handoff_from' | 'forked_from' | 'resumed_from' | 'sends_to';
+export interface EdgeCandidate {
+    relation: EdgeRelation;
+    target: string;
+    eventIndex: number;
+    operation: string;
+    command: string;
+    timestamp?: string;
+}
+/** Reads the session-reader invocations out of one tool call. */
+export declare function invocationsOf(event: TurnEvent): EdgeCandidate[];
+/**
+ * Derives L3 for one session from its stored events. Targets that do not
+ * resolve to an indexed session are dropped — a dangling edge is worse than
+ * no edge.
+ */
+export declare function deriveEdges(db: DatabaseSync, id: string, session: NormalizedSession): number;
+/**
+ * Records an edge at the moment it happens, when the caller session is known.
+ * Injected by a hook or the ACP context as `SESSION_READER_CALLER_SESSION`;
+ * absent everywhere else, in which case nothing is written.
+ */
+export declare function captureRuntimeEdge(db: DatabaseSync, verb: string, target: string): void;
+export interface EdgeView {
+    from: string;
+    to: string;
+    relation: EdgeRelation;
+    evidenceCount: number;
+    firstSeenAt?: string;
+    lastSeenAt?: string;
+    direction: 'out' | 'in';
+}
+export declare function edgesOf(db: DatabaseSync, id: string): EdgeView[];
+export declare function edgeEvidence(db: DatabaseSync, from: string, to: string, relation: string): {
+    eventIndex: number;
+    operation: string;
+    ts?: string;
+    extractor: string;
+}[];