@wirecat/cli-core 0.547.0 → 0.549.0

package/dist/store/sqlite/calendar.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { calendarText, entryInWindow, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
 import { listEvents } from "./calendar-events.js";
+import { forgetCalendarRows } from "./calendar-forget.js";
 import { bool, eventOf, fromJson, int, str, toJson } from "./events.js";
 import { driveDocumentOf, driveFileTarget, logFileLink } from "./files.js";
 import { identityOf } from "./identities.js";
@@ -524,6 +525,13 @@ export const eventStoreOver = (context) => {
                 .prepare("UPDATE calendars SET synced = ?, updated_at = ? WHERE id = ?")
                 .run(flag(synced), now, calendarId);
         }),
+        forgetCalendar: async (calendarId, now) => write(database, () => {
+            const accountId = Number(calendarRow(calendarId).account_id);
+            return forgetCalendarRows(database, { calendarId, accountId, cursorKey: cursorKey(calendarId), now }, {
+                event: refreshEvent,
+                series: refreshSeries,
+            });
+        }),
         saveEntries: async (calendarId, entries, now) => write(database, () => saveAll(calendarId, entries, now)),
         removeEntries: async (calendarId, externalIds, now) => write(database, () => removeAll(calendarId, externalIds, now)),
         markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => {

package/dist/store/sqlite/evidence-sources.d.ts

@@ -13,6 +13,8 @@ export interface EvidenceSource {
     /** Deleted at its source since it was cited, or no longer in the store. */
     missing: boolean;
 }
+/** Each distinct reference read back, in order; one the store no longer resolves keeps its reference, `missing`. */
+export declare const sourcesOfReferences: (database: CacheDatabase, references: readonly string[]) => EvidenceSource[];
 /**
  * Every `evidence` link from a memory or fact, in the order they were written, including one whose target was
  * deleted since: `evidenceOf` drops those, so a reader would never learn the record lost a source.
@@ -21,5 +23,3 @@ export declare const evidenceSourcesOf: (database: CacheDatabase, from: {
     type: string;
     id: number;
 }) => EvidenceSource[];
-/** Each distinct reference read back, in order; one the store no longer resolves keeps its reference, `missing`. */
-export declare const sourcesOfReferences: (database: CacheDatabase, references: readonly string[]) => EvidenceSource[];

package/dist/store/sqlite/evidence-sources.js

@@ -1,83 +1,47 @@
 import { linkKind } from "./link-kinds.js";
-import { referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
-const EXCERPT_CHARS = 280;
-const excerptOf = (text) => {
-    if (text == null)
-        return null;
-    const flat = String(text).replace(/\s+/g, " ").trim();
-    if (!flat)
-        return null;
-    return flat.length > EXCERPT_CHARS ? `${flat.slice(0, EXCERPT_CHARS - 1)}…` : flat;
-};
-const iso = (value) => (value == null ? null : new Date(Number(value)).toISOString());
-const textOf = (value) => (value == null || String(value).trim() === "" ? null : String(value));
-const READS = {
-    message: "SELECT c.title, coalesce(m.sender_name, i.name) AS sender, m.sent_at AS at, m.text AS body, a.provider AS tool " +
-        "FROM messages m JOIN chats c ON c.id = m.chat_id JOIN accounts a ON a.id = c.account_id " +
-        "LEFT JOIN identities i ON i.id = m.sender_identity_id WHERE m.id = ?",
-    email: "SELECT e.subject AS title, coalesce(e.from_name, e.from_address) AS sender, e.sent_at AS at, " +
-        "coalesce(e.body_text, e.snippet) AS body, 'email' AS tool FROM emails e WHERE e.id = ?",
-    note: "SELECT title, NULL AS sender, updated_at AS at, body, 'notes' AS tool FROM notes WHERE id = ?",
-    document: "SELECT d.title, NULL AS sender, coalesce(d.external_updated_at, d.updated_at) AS at, d.body, a.provider AS tool " +
-        "FROM documents d JOIN accounts a ON a.id = d.account_id WHERE d.id = ?",
-    meeting: "SELECT m.title, NULL AS sender, m.started_at AS at, m.description AS body, a.provider AS tool " +
-        "FROM meetings m JOIN accounts a ON a.id = m.account_id WHERE m.id = ?",
-    meeting_transcript: "SELECT m.title, NULL AS sender, m.started_at AS at, NULL AS body, a.provider AS tool FROM meeting_transcripts t " +
-        "JOIN meetings m ON m.id = t.meeting_id JOIN accounts a ON a.id = m.account_id WHERE t.id = ?",
-    meeting_transcript_row: "SELECT m.title, r.speaker_name AS sender, m.started_at + coalesce(r.start_ms, 0) AS at, r.text AS body, " +
-        "a.provider AS tool FROM meeting_transcript_rows r JOIN meeting_transcripts t ON t.id = r.meeting_transcript_id " +
-        "JOIN meetings m ON m.id = t.meeting_id JOIN accounts a ON a.id = m.account_id WHERE r.id = ?",
-};
-const KIND = {
-    meeting_transcript: "meeting",
-    meeting_transcript_row: "meeting",
-};
-const sourceOf = (database, thing) => {
-    const state = stateOfThing(database, thing);
-    const read = READS[thing.type];
-    const row = read === undefined || state === "unavailable" ? undefined : database.prepare(read).get(thing.id);
-    const gone = state !== "available";
-    return {
-        ref: referenceOfThing(database, thing) ?? null,
-        kind: KIND[thing.type] ?? thing.type,
-        title: textOf(row?.title),
-        sender: textOf(row?.sender),
-        at: iso(row?.at),
-        excerpt: gone ? null : excerptOf(row?.body),
-        tool: textOf(row?.tool),
-        missing: gone,
-    };
-};
+import { refReadsOf } from "./ref-summaries.js";
+import { referenceOfThing, storedThing } from "./things.js";
+/** A message is known by its chat here, not by the sender and time its summary title says. */
+const sourceOf = (read, ref) => ({
+    ref,
+    kind: read.kind,
+    title: read.kind === "message" ? read.in : read.title,
+    sender: read.sender,
+    at: read.at,
+    excerpt: read.excerpt,
+    tool: read.provider,
+    missing: read.state !== "available",
+});
+/** Each distinct reference read back, in order; one the store no longer resolves keeps its reference, `missing`. */
+export const sourcesOfReferences = (database, references) => [...refReadsOf(database, references, { excerpt: true })].map(([ref, read]) => sourceOf(read, ref));
+const GONE_KIND = { meeting_transcript: "meeting", meeting_transcript_row: "meeting" };
 /**
  * Every `evidence` link from a memory or fact, in the order they were written, including one whose target was
  * deleted since: `evidenceOf` drops those, so a reader would never learn the record lost a source.
  */
-export const evidenceSourcesOf = (database, from) => database
-    .prepare(`SELECT to_type, to_id FROM links WHERE from_type = ? AND from_id = ? AND kind = ${linkKind("evidence")} ` +
-    "AND to_id IS NOT NULL ORDER BY id")
-    .all(from.type, from.id)
-    .map((link) => sourceOf(database, storedThing(link.to_type, link.to_id)));
-const thingNamed = (database, reference) => {
-    try {
-        return thingOf(database, reference);
-    }
-    catch {
-        return undefined;
-    }
+export const evidenceSourcesOf = (database, from) => {
+    const cited = database
+        .prepare(`SELECT to_type, to_id FROM links WHERE from_type = ? AND from_id = ? AND kind = ${linkKind("evidence")} ` +
+        "AND to_id IS NOT NULL ORDER BY id")
+        .all(from.type, from.id)
+        .map((link) => {
+        const thing = storedThing(link.to_type, link.to_id);
+        return { type: thing.type, ref: referenceOfThing(database, thing) };
+    });
+    const reads = refReadsOf(database, cited.flatMap(({ ref }) => ref ?? []), { excerpt: true });
+    return cited.map(({ type, ref }) => {
+        const read = ref === undefined ? undefined : reads.get(ref);
+        if (ref !== undefined && read !== undefined)
+            return sourceOf(read, ref);
+        return {
+            ref: null,
+            kind: GONE_KIND[type] ?? type,
+            title: null,
+            sender: null,
+            at: null,
+            excerpt: null,
+            tool: null,
+            missing: true,
+        };
+    });
 };
-/** Each distinct reference read back, in order; one the store no longer resolves keeps its reference, `missing`. */
-export const sourcesOfReferences = (database, references) => [...new Set(references)].map((reference) => {
-    const thing = thingNamed(database, reference);
-    if (thing)
-        return { ...sourceOf(database, thing), ref: reference };
-    return {
-        ref: reference,
-        kind: reference.startsWith("msg:") ? "message" : reference.split(":")[0] || "unknown",
-        title: null,
-        sender: null,
-        at: null,
-        excerpt: null,
-        tool: null,
-        missing: true,
-    };
-});

package/dist/store/sqlite/knowledge.d.ts

@@ -1,17 +1,17 @@
 import { type QueryAst } from "@wirecat/cli-base/query";
 import { type Decider } from "../decisions.js";
 import type { AccountKey } from "../types.js";
-import { RELATION_KINDS } from "./link-kinds.js";
 import { type MeetingProjectsStore } from "./meeting-projects.js";
 import type { Author } from "./memories.js";
 import { type Link } from "./notes.js";
 import type { StoreContext } from "./open.js";
 import type { ProposedAction } from "./proposed-actions.js";
-import { type LinkDecision } from "./relation-proposals.js";
+import { type KnowledgeRelation, type LinkDecision, type RelateInput, type RelationUpdate } from "./relation-proposals.js";
 import type { TagCreationOptions } from "./tag-creation.js";
 import { type Label, type TagKind, type TagRow } from "./tags.js";
 import { type ThingState } from "./things.js";
 import { type VocabularyStore } from "./vocabulary.js";
+export type { KnowledgeRelation, RelateInput } from "./relation-proposals.js";
 export type { Label } from "./tags.js";
 export type KnowledgeTarget = {
     type: "message";
@@ -90,18 +90,6 @@ export interface Project {
     scope: (typeof SCOPES)[number];
     createdAt: string;
 }
-export interface KnowledgeRelation {
-    id: string;
-    from: string;
-    to: string;
-    kind: (typeof RELATION_KINDS)[number];
-    role: string | null;
-    evidence: string | null;
-    confirmed: boolean;
-    provenance: string | null;
-    confidenceCategory: "owner-confirmed" | "weak";
-    createdAt: string;
-}
 export interface Reminder {
     id: string;
     task: string;
@@ -199,9 +187,24 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         to: string;
         kind: KnowledgeRelation["kind"];
         role?: string;
+        purpose?: string;
         evidence?: string[];
         reason?: string;
     }, by: Exclude<Author, "owner">): Promise<ProposedAction>;
+    /** The owner sets a relationship's role and purpose; `null` clears one. */
+    updateRelation(key: KnowledgeScope, id: string, input: RelationUpdate & {
+        by: "owner";
+    }): Promise<KnowledgeRelation>;
+    /** An agent's change is a `relationship_update` proposal for the owner; the same pending change is answered again. */
+    updateRelation(key: KnowledgeScope, id: string, input: RelationUpdate & {
+        by: Exclude<Author, "owner">;
+        reason?: string;
+    }): Promise<ProposedAction>;
+    /** Decides a `relationship_update` proposal; a confirmed one changes the relationship in the same transaction. */
+    decideRelationUpdate(id: string, decision: LinkDecision): Promise<{
+        proposal: ProposedAction;
+        relation: KnowledgeRelation | null;
+    }>;
     /** Decides a stored `relationship` or `key_document` proposal; the link and the decision land together. */
     decideLinkProposal(id: string, decision: LinkDecision): Promise<{
         proposal: ProposedAction;
@@ -229,13 +232,4 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
     }): Promise<Reminder[]>;
     acknowledgeReminder(key: AccountKey, id: string, receipt: string): Promise<Reminder>;
 }
-export interface RelateInput {
-    from: string;
-    to: string;
-    kind: KnowledgeRelation["kind"];
-    role?: string;
-    evidence?: string;
-    confirmed?: boolean;
-    provenance?: string;
-}
 export declare const knowledgeStoreOver: (context: StoreContext) => KnowledgeStore;

package/dist/store/sqlite/knowledge.js

@@ -15,7 +15,7 @@ import { meetingProjectsStoreOver } from "./meeting-projects.js";
 import { holdingText } from "./note-index.js";
 import { insertLink, linkOf } from "./notes.js";
 import { queryFilter } from "./query-filter.js";
-import { relationProposalsOver } from "./relation-proposals.js";
+import { relationOf, relationProposalsOver, } from "./relation-proposals.js";
 import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, liveTagging, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
 import { INBOX_KEY_LENGTH, TASK_KEY_PREFIXES } from "./task-keys.js";
 import { inboxKey, taskAccountOf, taskIdOf, taskRowOf } from "./tasks.js";
@@ -221,18 +221,6 @@ export const knowledgeStoreOver = (context) => {
         scope: row.scope,
         createdAt: iso(row.created_at),
     });
-    const relationOf = (link) => ({
-        id: link.id,
-        from: link.from,
-        to: String(link.to),
-        kind: link.kind,
-        role: link.role,
-        evidence: link.evidence,
-        confirmed: link.confirmed,
-        provenance: link.provenance,
-        confidenceCategory: link.confirmed ? "owner-confirmed" : "weak",
-        createdAt: link.createdAt,
-    });
     const proposals = relationProposalsOver(context);
     const RELATIONS = `SELECT * FROM links WHERE kind IN (${RELATION_KINDS.map(linkKind).join(",")}) AND to_id IS NOT NULL`;
     const relation = (id) => {
@@ -561,6 +549,7 @@ export const knowledgeStoreOver = (context) => {
                 origin: confirmed ? "owner" : "suggested",
                 confirmed,
                 ...(input.role === undefined ? {} : { role: input.role }),
+                ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
                 ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
                 ...(input.provenance === undefined ? {} : { provenance: input.provenance }),
             })));
@@ -573,6 +562,17 @@ export const knowledgeStoreOver = (context) => {
                 });
             return proposals.propose(from, input, by);
         },
+        updateRelation: (async (key, id, input) => {
+            checked(key);
+            const link = linkOf(database, relation(id));
+            if (input.by === "owner")
+                return relationOf(proposals.update(link, input));
+            return proposals.proposeUpdate(link, input, input.by);
+        }),
+        decideRelationUpdate: async (id, decision) => {
+            const { proposal, link } = proposals.decideUpdate(id, decision);
+            return { proposal, relation: link && relationOf(link) };
+        },
         decideLinkProposal: async (id, decision) => proposals.decideProposal(id, decision),
         decideSuggestedLink: async (id, decision) => proposals.decideLink(id, decision),
         relations: async (key, reference) => {

package/dist/store/sqlite/manifest.js

@@ -57,6 +57,8 @@ export const MANIFEST = [
     { name: "20261031230945_version-41-task-fields", version: 41, minCompatible: 34 },
     { name: "20261101002523_version-42-task-revision", version: 42, minCompatible: 34 },
     { name: "20261101011859_version-43-memory-project", version: 43, minCompatible: 34 },
+    { name: "20261102050533_version-44-relationship-purpose", version: 44, minCompatible: 34 },
+    { name: "20261102050534_version-44-suggested-links-move", version: 44, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -877,5 +877,17 @@ export const GENERATED = [
             "ALTER TABLE `memories` ADD `project_id` integer REFERENCES projects(id);",
             "CREATE INDEX `memories_by_project_id` ON `memories` (`project_id`);"
         ]
+    },
+    {
+        "name": "20261102050533_version-44-relationship-purpose",
+        "statements": [
+            "ALTER TABLE `links` ADD `purpose` text;"
+        ]
+    },
+    {
+        "name": "20261102050534_version-44-suggested-links-move",
+        "statements": [
+            "-- A suggestion's references (chat:, msg:) need the store's own encoding, which SQL cannot write, so the next writable\n-- open moves the unconfirmed agent and rule links into `proposed_actions` and deletes this key (moveSuggestedLinks).\nINSERT OR REPLACE INTO store_settings (key, value, at) VALUES ('suggested_links_to_move', '1', unixepoch() * 1000);"
+        ]
     }
 ];

package/dist/store/sqlite/notes.d.ts

@@ -56,6 +56,8 @@ export interface Link {
     origin: (typeof LINK_SOURCES)[number];
     targetText: string | null;
     role: string | null;
+    /** What a chat is for in a project, from the purposes memo's config lists; `null` means `work`. */
+    purpose: string | null;
     evidence: string | null;
     provenance: string | null;
     confirmed: boolean;
@@ -79,6 +81,7 @@ export interface LinkInput {
     anchor?: string;
     origin?: (typeof LINK_ORIGINS)[number];
     role?: string;
+    purpose?: string;
     evidence?: string;
     provenance?: string;
     confirmed?: boolean;
@@ -194,6 +197,8 @@ export declare const requiredThing: (database: CacheDatabase, reference: string,
  * and only a name some note is waiting for costs more.
  */
 export declare const resolvePersonLinks: (database: CacheDatabase, names: (string | null | undefined)[]) => void;
+/** The store keeps no list of purposes: memo's config holds it, and checks a purpose before it gets here. */
+export declare const purposeOf: (purpose: string) => string;
 /** Writes one link; an identical resolved link is answered instead of doubled. */
 export declare const insertLink: (context: StoreContext, input: LinkInput) => Link;
 export declare const notesStoreOver: (context: StoreContext) => Omit<NotesStore, keyof NoteSearch>;

package/dist/store/sqlite/notes.js

@@ -87,6 +87,7 @@ export const linkOf = (database, row) => {
         origin: row.source,
         targetText: row.target_text == null ? null : String(row.target_text),
         role: row.role == null ? null : String(row.role),
+        purpose: row.purpose == null ? null : String(row.purpose),
         evidence: row.evidence == null ? null : String(row.evidence),
         provenance: metadata.provenance ?? null,
         confirmed: Number(row.confirmed) === 1,
@@ -164,6 +165,8 @@ const ownerLink = (input) => {
         });
     return input;
 };
+/** The store keeps no list of purposes: memo's config holds it, and checks a purpose before it gets here. */
+export const purposeOf = (purpose) => textOf(purpose, "a purpose", 100);
 /** Writes one link; an identical resolved link is answered instead of doubled. */
 export const insertLink = (context, input) => {
     const { database, now } = context;
@@ -187,8 +190,9 @@ export const insertLink = (context, input) => {
     const provenance = input.provenance === undefined ? undefined : textOf(input.provenance, "provenance", 2000);
     const row = database
         .prepare("INSERT INTO links (from_type, from_id, to_type, to_id, kind, anchor, source, target_text, target_folded, role, evidence, " +
-        "metadata, confirmed, created_at, author, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-        .get(from.type, from.id, to?.type ?? null, to?.id ?? null, kind, input.anchor ?? null, origin, targetText, targetText === null ? null : targetKey(targetText), input.role === undefined ? null : textOf(input.role, "a role", 200), input.evidence === undefined ? null : textOf(input.evidence, "evidence", 2000), provenance === undefined ? null : JSON.stringify({ provenance }), input.confirmed === false ? 0 : 1, at, origin === "owner" ? "owner" : null, at);
+        "metadata, confirmed, created_at, author, updated_at, purpose) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
+        "RETURNING id")
+        .get(from.type, from.id, to?.type ?? null, to?.id ?? null, kind, input.anchor ?? null, origin, targetText, targetText === null ? null : targetKey(targetText), input.role === undefined ? null : textOf(input.role, "a role", 200), input.evidence === undefined ? null : textOf(input.evidence, "evidence", 2000), provenance === undefined ? null : JSON.stringify({ provenance }), input.confirmed === false ? 0 : 1, at, origin === "owner" ? "owner" : null, at, input.purpose === undefined ? null : purposeOf(input.purpose));
     if (to === null && targetText !== null)
         resolveKey(database, targetKey(targetText));
     return linkOf(database, database.prepare("SELECT * FROM links WHERE id = ?").get(Number(row?.id)));

package/dist/store/sqlite/open-store.js

@@ -16,6 +16,7 @@ import { loadProviders } from "./providers.js";
 import { assertReadCompatible } from "./read-compatibility.js";
 import { stemsState } from "./stems.js";
 import { fillStems, followDefaultStemmers } from "./stems-fill.js";
+import { moveSuggestedLinks } from "./suggested-links.js";
 import { fillVectorIndexes } from "./vector-index.js";
 export const BACKFILL_ON_OPEN = 5_000;
 const NOT_WRITABLE = new Set(["EACCES", "EPERM", "EROFS"]);
@@ -55,6 +56,7 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, ver
             fillFiles(database, now);
             fillFolded(database);
             fillJoinKeys(database);
+            moveSuggestedLinks(database, now);
             const pending = pendingNormalization(database);
             if (pending > 0 && pending <= BACKFILL_ON_OPEN)
                 backfillNormalized(database);

package/dist/store/sqlite/proposed-actions.d.ts

@@ -81,7 +81,7 @@ type ProposalOperations = Omit<{
     proposer(id: string): Proposer;
 };
 /** Who proposed an action, for `mayDecide`. */
-export declare const proposerOfAction: ({ proposedBy }: ProposedAction) => Proposer;
+export declare const proposerOfAction: ({ proposedBy, payload }: ProposedAction) => Proposer;
 export declare const proposalOperationsOver: (context: StoreContext) => ProposalOperations;
 export declare const proposedActionsStoreOver: (context: StoreContext) => ProposedActionsStore;
 export {};

package/dist/store/sqlite/proposed-actions.js

@@ -20,11 +20,19 @@ const STATUS = `CASE WHEN p.status = 'approved' AND p.kind IN ('${MEETING_FINDIN
 const NAMED = `SELECT p.*, ${STATUS} AS shown_status, b.name AS proposer_name, b.kind AS proposer_kind FROM proposed_actions p ` +
     "LEFT JOIN bots b ON p.proposed_by_type = 'bot' AND b.id = p.proposed_by_id";
 /** Who proposed an action, for `mayDecide`. */
-export const proposerOfAction = ({ proposedBy }) => proposedBy.type === "person"
+export const proposerOfAction = ({ proposedBy, payload }) => proposedBy.type === "person"
     ? { type: "person", id: proposedBy.id }
     : proposedBy.name === null
         ? { type: "unknown" }
-        : { type: "bot", id: proposedBy.id, name: proposedBy.name, kind: proposedBy.kind ?? "agent" };
+        : {
+            type: "bot",
+            id: proposedBy.id,
+            name: proposedBy.name,
+            kind: proposedBy.kind ?? "agent",
+            ...(movedSuggestion(payload) ? { verified: false } : {}),
+        };
+/** A suggestion moved from `links` names its bot only as the link's provenance text said it (store version 44). */
+const movedSuggestion = (payload) => typeof payload === "object" && payload !== null && "suggestedLink" in payload;
 export const proposalOperationsOver = (context) => {
     const { database, now } = context;
     const actionOf = (row) => {

package/dist/store/sqlite/ref-summaries.d.ts

@@ -0,0 +1,17 @@
+import { type RefSummary } from "../../domain/ref-summaries.js";
+import type { CacheDatabase } from "../driver.js";
+/** A summary plus what an evidence reader shows beside it; `summaries` drops the extra fields. */
+export interface RefRead extends RefSummary {
+    sender: string | null;
+    excerpt: string | null;
+}
+/**
+ * Every ref read back in one statement per kind present, keyed by the text passed and in its order. A bad ref is
+ * `unknown` and a ref the store lacks is `unavailable`: one bad row must not fail a page of them.
+ */
+export declare const refReadsOf: (database: CacheDatabase, texts: readonly string[], { excerpt }?: {
+    excerpt?: boolean;
+}) => Map<string, RefRead>;
+export declare const refSummariesOf: (database: CacheDatabase, texts: readonly string[], options?: {
+    excerpt?: boolean;
+}) => Map<string, RefSummary>;