@wirecat/cli-core 0.537.0 → 0.539.0

package/dist/calendar/ics.js

@@ -0,0 +1,314 @@
+import { CliError } from "@wirecat/cli-base";
+import { zonedMoment } from "@wirecat/cli-base/query";
+const CRLF = "\r\n";
+const LINE_OCTETS = 75;
+const escapeText = (text) => text
+    .replace(/\\/gu, "\\\\")
+    .replace(/;/gu, "\\;")
+    .replace(/,/gu, "\\,")
+    .replace(/\r\n|\r|\n/gu, "\\n");
+/** A parameter value: quoted when it holds `:`, `;` or `,`; a double quote cannot be written in one, so it goes. */
+const paramValue = (text) => {
+    const clean = text.replace(/["\r\n]/gu, "");
+    return /[:;,]/u.test(clean) ? `"${clean}"` : clean;
+};
+/** Lines longer than 75 octets go on under a leading space, never splitting a character's UTF-8 bytes. */
+export const foldLine = (line) => {
+    const parts = [];
+    let current = "";
+    let octets = 0;
+    for (const char of line) {
+        const size = Buffer.byteLength(char, "utf8");
+        const room = parts.length === 0 ? LINE_OCTETS : LINE_OCTETS - 1;
+        if (octets + size > room) {
+            parts.push(current);
+            current = "";
+            octets = 0;
+        }
+        current += char;
+        octets += size;
+    }
+    parts.push(current);
+    return parts.join(`${CRLF} `);
+};
+const pad = (value) => String(value).padStart(2, "0");
+const utcStamp = (at) => {
+    const date = new Date(at);
+    return (`${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T` +
+        `${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`);
+};
+const dateValue = (date) => date.replaceAll("-", "");
+const PARTSTAT = {
+    "needs-action": "NEEDS-ACTION",
+    accepted: "ACCEPTED",
+    tentative: "TENTATIVE",
+    declined: "DECLINED",
+    delegated: "DELEGATED",
+};
+const eventLines = (event, stamp) => {
+    const lines = ["BEGIN:VEVENT", `UID:${escapeText(event.uid)}`, `DTSTAMP:${stamp}`];
+    if (event.startDate !== undefined && event.endDate !== undefined)
+        lines.push(`DTSTART;VALUE=DATE:${dateValue(event.startDate)}`, `DTEND;VALUE=DATE:${dateValue(event.endDate)}`);
+    else if (event.startsAt !== undefined)
+        lines.push(`DTSTART:${utcStamp(event.startsAt)}`, `DTEND:${utcStamp(event.endsAt ?? event.startsAt)}`);
+    if (event.title)
+        lines.push(`SUMMARY:${escapeText(event.title)}`);
+    if (event.description)
+        lines.push(`DESCRIPTION:${escapeText(event.description)}`);
+    if (event.location)
+        lines.push(`LOCATION:${escapeText(event.location)}`);
+    for (const rule of event.recurrence ?? [])
+        lines.push(rule);
+    if (event.status)
+        lines.push(`STATUS:${event.status.toUpperCase()}`);
+    if (event.transparency)
+        lines.push(`TRANSP:${event.transparency.toUpperCase()}`);
+    if (event.organizer)
+        lines.push(`ORGANIZER${event.organizer.name ? `;CN=${paramValue(event.organizer.name)}` : ""}:mailto:${event.organizer.email}`);
+    for (const one of event.attendees ?? []) {
+        const params = [
+            ...(one.name ? [`CN=${paramValue(one.name)}`] : []),
+            ...(one.response ? [`PARTSTAT=${PARTSTAT[one.response]}`] : []),
+            ...(one.optional ? ["ROLE=OPT-PARTICIPANT"] : []),
+        ];
+        lines.push(`ATTENDEE${params.map((param) => `;${param}`).join("")}:mailto:${one.email}`);
+    }
+    if (event.url)
+        lines.push(`URL:${event.url}`);
+    lines.push("END:VEVENT");
+    return lines;
+};
+/** One VCALENDAR holding the events, CRLF line ends and folded lines, as RFC 5545 §3.1 asks. */
+export const writeIcs = (events, options) => [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    `PRODID:-//WireCat//${options.product.replace(/[^\w .-]/gu, "")}//EN`,
+    "CALSCALE:GREGORIAN",
+    ...events.flatMap((event) => eventLines(event, utcStamp(options.now))),
+    "END:VCALENDAR",
+]
+    .map(foldLine)
+    .join(CRLF)
+    .concat(CRLF);
+const contentLine = (line) => {
+    let at = 0;
+    let quoted = false;
+    for (; at < line.length; at++) {
+        const char = line[at];
+        if (char === '"')
+            quoted = !quoted;
+        else if (char === ":" && !quoted)
+            break;
+    }
+    if (at === line.length)
+        return null;
+    const head = line.slice(0, at);
+    const parts = [];
+    let part = "";
+    quoted = false;
+    for (const char of head) {
+        if (char === '"')
+            quoted = !quoted;
+        if (char === ";" && !quoted) {
+            parts.push(part);
+            part = "";
+        }
+        else
+            part += char;
+    }
+    parts.push(part);
+    const [name = "", ...rest] = parts;
+    const params = {};
+    for (const param of rest) {
+        const equals = param.indexOf("=");
+        if (equals > 0)
+            params[param.slice(0, equals).toUpperCase()] = param.slice(equals + 1).replace(/^"|"$/gu, "");
+    }
+    return { name: name.toUpperCase(), params, value: line.slice(at + 1) };
+};
+const unescapeText = (text) => text.replace(/\\([\\;,nN])/gu, (_match, char) => (char === "n" || char === "N" ? "\n" : char));
+const DATE = /^(\d{4})(\d{2})(\d{2})$/u;
+const DATE_TIME = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z?)$/u;
+/** A DATE or DATE-TIME: UTC with `Z`, in its TZID, or floating, read in `zone`. */
+const momentOf = (line, zone) => {
+    const value = line.value.trim();
+    const date = DATE.exec(value);
+    if (date || line.params.VALUE === "DATE") {
+        if (!date)
+            throw new Error(`${line.name} ${value} is not a date`);
+        return { date: `${date[1]}-${date[2]}-${date[3]}` };
+    }
+    const time = DATE_TIME.exec(value);
+    if (!time)
+        throw new Error(`${line.name} ${value} is not a date or a time`);
+    const [, year, month, day, hour, minute, second, utc] = time;
+    const local = `${year}-${month}-${day}T${hour}:${minute}:${second}`;
+    if (utc)
+        return { at: Date.parse(`${local}Z`), zone: "UTC" };
+    const named = line.params.TZID;
+    const where = named ?? zone;
+    try {
+        return { at: zonedMoment(local, where, { start: 0, end: local.length }), zone: where };
+    }
+    catch {
+        throw new Error(`${line.name} names the time zone ${where}, which is not an IANA zone such as Europe/Madrid`);
+    }
+};
+const DURATION = /^([+-])?P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/u;
+const durationMs = (text) => {
+    const found = DURATION.exec(text.trim());
+    if (!found || found[1] === "-")
+        throw new Error(`DURATION ${text} is not a length of time`);
+    const [, , weeks, days, hours, minutes, seconds] = found.map((one) => Number(one ?? 0));
+    return ((((weeks * 7 + days) * 24 + hours) * 60 + minutes) * 60_000 +
+        seconds * 1000);
+};
+const plusDays = (date, days) => {
+    const [year, month, day] = date.split("-").map(Number);
+    return new Date(Date.UTC(year, month - 1, day + days)).toISOString().slice(0, 10);
+};
+const STATUS = { CONFIRMED: "confirmed", TENTATIVE: "tentative", CANCELLED: "cancelled" };
+const RESPONSE = {
+    "NEEDS-ACTION": "needs-action",
+    ACCEPTED: "accepted",
+    TENTATIVE: "tentative",
+    DECLINED: "declined",
+    DELEGATED: "delegated",
+};
+const emailOf = (value) => {
+    const email = value
+        .trim()
+        .replace(/^mailto:/iu, "")
+        .toLowerCase();
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/u.test(email) ? email : null;
+};
+const eventOf = (lines, zone) => {
+    const one = (name) => lines.find((line) => line.name === name);
+    const uid = one("UID")?.value.trim();
+    if (!uid)
+        throw new Error("the event has no UID");
+    if (one("RECURRENCE-ID"))
+        throw new Error("a changed occurrence of a repeating event (RECURRENCE-ID) is not imported on its own");
+    const startLine = one("DTSTART");
+    if (!startLine)
+        throw new Error("the event has no DTSTART");
+    const start = momentOf(startLine, zone);
+    const endLine = one("DTEND");
+    const duration = one("DURATION");
+    const text = (name) => {
+        const found = one(name);
+        return found ? unescapeText(found.value) : null;
+    };
+    const event = { uid, title: text("SUMMARY") };
+    if ("date" in start) {
+        const end = endLine ? momentOf(endLine, zone) : undefined;
+        if (end && !("date" in end))
+            throw new Error("DTSTART is a date and DTEND a time");
+        event.startDate = start.date;
+        event.endDate =
+            end?.date ?? plusDays(start.date, duration ? Math.max(1, Math.ceil(durationMs(duration.value) / 86_400_000)) : 1);
+        if (event.endDate <= event.startDate)
+            throw new Error("the event ends before it starts");
+    }
+    else {
+        const end = endLine ? momentOf(endLine, zone) : undefined;
+        if (end && "date" in end)
+            throw new Error("DTSTART is a time and DTEND a date");
+        event.startsAt = start.at;
+        event.endsAt = end?.at ?? start.at + (duration ? durationMs(duration.value) : 0);
+        event.timezone = start.zone;
+        if (event.endsAt < event.startsAt)
+            throw new Error("the event ends before it starts");
+    }
+    const description = text("DESCRIPTION");
+    if (description)
+        event.description = description;
+    const location = text("LOCATION");
+    if (location)
+        event.location = location;
+    const recurrence = lines
+        .filter(({ name }) => ["RRULE", "RDATE", "EXDATE"].includes(name))
+        .map(({ name, params, value }) => {
+        const kept = Object.entries(params).map(([key, param]) => `;${key}=${paramValue(param)}`);
+        return `${name}${kept.join("")}:${value.trim()}`;
+    });
+    if (recurrence.length)
+        event.recurrence = recurrence;
+    const status = STATUS[one("STATUS")?.value.trim().toUpperCase() ?? ""];
+    if (status)
+        event.status = status;
+    const transparency = one("TRANSP")?.value.trim().toUpperCase();
+    if (transparency === "TRANSPARENT" || transparency === "OPAQUE")
+        event.transparency = transparency === "TRANSPARENT" ? "transparent" : "opaque";
+    const organizerLine = one("ORGANIZER");
+    const organizer = organizerLine && emailOf(organizerLine.value);
+    if (organizerLine && organizer)
+        event.organizer = { email: organizer, name: organizerLine.params.CN ?? null };
+    const attendees = lines
+        .filter(({ name }) => name === "ATTENDEE")
+        .flatMap(({ params, value }) => {
+        const email = emailOf(value);
+        if (!email)
+            return [];
+        return [
+            {
+                email,
+                name: params.CN ?? null,
+                response: RESPONSE[(params.PARTSTAT ?? "").toUpperCase()] ?? null,
+                optional: (params.ROLE ?? "").toUpperCase() === "OPT-PARTICIPANT",
+            },
+        ];
+    });
+    if (attendees.length)
+        event.attendees = attendees;
+    const url = one("URL")?.value.trim();
+    if (url)
+        event.url = url;
+    return event;
+};
+/**
+ * The VEVENTs of an iCalendar text; times with neither `Z` nor a TZID are read in `zone`. An event that cannot be
+ * imported alone is in `skipped` with the reason; a text with no VCALENDAR is refused.
+ */
+export const readIcs = (text, zone) => {
+    const unfolded = text.replace(/^\uFEFF/u, "").replace(/\r?\n[ \t]/gu, "");
+    const lines = unfolded.split(/\r?\n/u).filter((line) => line.trim() !== "");
+    if (!/^BEGIN:VCALENDAR$/iu.test(lines[0]?.trim() ?? ""))
+        throw new CliError("validation_error", "the file is not iCalendar: it does not start with BEGIN:VCALENDAR", {
+            reason: "ics.not-icalendar",
+        });
+    const events = [];
+    const skipped = [];
+    let held = null;
+    // Components inside a VEVENT, such as VALARM, are passed over whole.
+    let inner = 0;
+    for (const raw of lines) {
+        const line = contentLine(raw);
+        if (!line)
+            continue;
+        const value = line.value.trim().toUpperCase();
+        if (line.name === "BEGIN" && value === "VEVENT" && held === null) {
+            held = [];
+            continue;
+        }
+        if (held === null)
+            continue;
+        if (line.name === "BEGIN")
+            inner++;
+        else if (line.name === "END" && inner > 0)
+            inner--;
+        else if (line.name === "END" && value === "VEVENT") {
+            try {
+                events.push(eventOf(held, zone));
+            }
+            catch (error) {
+                const uid = held.find(({ name }) => name === "UID")?.value.trim() || null;
+                skipped.push({ uid, reason: error instanceof Error ? error.message : String(error) });
+            }
+            held = null;
+        }
+        else if (inner === 0)
+            held.push(line);
+    }
+    return { events, skipped };
+};

package/dist/calendar/index.d.ts

@@ -1,4 +1,5 @@
 export type { CalendarAccessRole, CalendarInput, EntryAttachment, EntryAttachmentInput, EntryEventType, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EntryTransparency, EntryVisibility, EventDetails, EventFilter, EventStore, LinkReview, ParticipantResponse, ReviewDecision, StoredCalendar, StoredEntry, StoredParticipant, } from "../meetings/index.js";
+export { type IcsEvent, type IcsSkip, readIcs, writeIcs } from "./ics.js";
 export { repeatRule } from "./recurrence.js";
 export type { BusyTimes, CalendarExpander, CalendarSource, CalendarSourceTraits, ChangePage, ChangeResult, FreeBusyRequest, SearchPage, SyncWindow, } from "./source.js";
 export { type CalendarCursor, type CalendarSyncOptions, type CalendarSyncReport, type CalendarSyncResult, calendarStatus, calendarSyncWindow, type PendingRound, parseCalendarCursor, syncCalendars, } from "./sync.js";

package/dist/calendar/index.js

@@ -1,3 +1,4 @@
+export { readIcs, writeIcs } from "./ics.js";
 export { repeatRule } from "./recurrence.js";
 export { calendarStatus, calendarSyncWindow, parseCalendarCursor, syncCalendars, } from "./sync.js";
 export { CALENDAR_WRITE_DEFAULTS, CALENDAR_WRITE_KEYS, calendarConflict, EVENTS_DELETE_SERIES_KEY, EVENTS_NOTIFY_KEY, } from "./writer.js";

package/dist/calendar/prepare.d.ts

@@ -0,0 +1,134 @@
+import type { EventDetails, EventStore } from "../meetings/index.js";
+import { type ContextEvent, type ContextMessage } from "../services/person-context.js";
+import { type PersonMeetingContextItem } from "../services/person-meeting-context.js";
+import type { MessageStore } from "../store/store.js";
+import { type PersonOfEmail, type ReadAccount } from "./reads.js";
+export declare const PREPARE_MESSAGES = 5;
+/** Attendees past this many are listed without their messages: a meeting of fifty would not fit any budget. */
+export declare const PREPARE_PEOPLE = 10;
+export declare const PREPARE_BYTES: number;
+/** The account's next meeting that has not started yet, by the rule of `isMeeting`. */
+export declare const nextMeeting: (store: EventStore, accountId: number, now: number) => Promise<EventDetails>;
+export interface PreparationOptions {
+    store: EventStore;
+    messages: MessageStore;
+    account: ReadAccount;
+    personOf: PersonOfEmail;
+    now: number;
+    /** Messages per person, each list. */
+    limit?: number;
+    /** ms: no message or meeting older. */
+    since?: number;
+}
+/**
+ * The stored evidence for one meeting: the event, and for each attendee other than the owner, their linked identities,
+ * their latest messages and mail, the events and recorded meetings they shared with the owner. Reads the store only,
+ * every account that saw each person (WC-ACCT-9), and writes nothing; the brief is the agent's.
+ */
+export declare const eventPreparation: (details: EventDetails, options: PreparationOptions) => Promise<{
+    event: {
+        id: string;
+        event_series_id: string | null;
+        title: string | null;
+        description: string | null;
+        location: string | null;
+        starts_at: string | null;
+        ends_at: string | null;
+        timezone: string | null;
+        origin: "auto" | "calendar" | "owner";
+        status: string | null;
+        all_day: boolean;
+        source_deleted_at: string | null;
+        deleted_at: string | null;
+        created_at: string;
+        updated_at: string;
+        untrusted?: string[] | undefined;
+        change?: "cancelled" | "moved" | "new" | undefined;
+        changed_at?: string | null | undefined;
+        was?: {
+            starts_at: string | null;
+            ends_at: string | null;
+        } | undefined;
+        overlapping?: boolean | undefined;
+        overlaps?: string[] | undefined;
+        ref: string;
+        entries: {
+            id: string;
+            calendar_id: string;
+            external_id: string;
+            kind: import("../meetings/event-store.js").EntryKind;
+            title: string | null;
+            status: import("../meetings/event-store.js").EntryStatus;
+            event_type: import("../meetings/event-store.js").EntryEventType | null;
+            own_response: import("../meetings/event-store.js").ParticipantResponse | null;
+            starts_at: string | null;
+            ends_at: string | null;
+            join_url: string | null;
+            url: string | null;
+            deleted_at: string | null;
+        }[];
+        attendees: {
+            email: string;
+            name: string | null;
+            response: import("../meetings/event-store.js").ParticipantResponse | null;
+            organizer: boolean;
+            optional: boolean;
+            resource: boolean;
+            self: boolean;
+            person: string | null;
+        }[];
+        attachments: {
+            file_id: string;
+            title: string | null;
+            document: string | null;
+        }[];
+        history: {
+            title: string | null;
+            starts_at: string | null;
+            ends_at: string | null;
+            location: string | null;
+            status: string | null;
+            changed_at: string;
+        }[];
+    };
+    people: {
+        email: string;
+        name: string | null;
+        response: string | null;
+        organizer: boolean;
+        optional: boolean;
+        person: string | null;
+        read: boolean;
+        identities: string[];
+        recent: {
+            direct: ContextMessage[];
+            groups: ContextMessage[];
+        };
+        pastEvents: ContextEvent[];
+        meetings: PersonMeetingContextItem[];
+        hasMore: boolean;
+    }[];
+    limits: {
+        people: number;
+        messages: number;
+        bytes: number;
+    };
+    untrusted: string[];
+    meta: Pick<{
+        run_id: string;
+        duration_ms: number;
+        accounts?: string[] | undefined;
+        complete: boolean;
+        issues?: {
+            code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
+            reason?: string | undefined;
+            source: string;
+        }[] | undefined;
+        truncated?: boolean | undefined;
+        timezone?: string | undefined;
+        window?: {
+            since?: string | undefined;
+            until?: string | undefined;
+        } | undefined;
+    }, "accounts" | "complete" | "issues" | "truncated">;
+}>;

package/dist/calendar/prepare.js

@@ -0,0 +1,179 @@
+import { CliError } from "@wirecat/cli-base";
+import { parseMeetingReference } from "../meetings/index.js";
+import { readsOf, recordContext } from "../services/person-context.js";
+import { personMeetingContext } from "../services/person-meeting-context.js";
+import { accountsMeta, CALENDAR_UNTRUSTED_FIELDS, eventAnswer, eventOf, } from "./reads.js";
+export const PREPARE_MESSAGES = 5;
+/** Attendees past this many are listed without their messages: a meeting of fifty would not fit any budget. */
+export const PREPARE_PEOPLE = 10;
+export const PREPARE_BYTES = 128 * 1024;
+const PERSON_BYTES = 24 * 1024;
+const MEETINGS = 2;
+const CUES = 5;
+/** How many upcoming events the next-meeting rule looks at before it gives up. */
+const NEXT_SCAN = 200;
+const NEXT_PAGE = 50;
+const nameOf = ({ provider, account }) => `${provider}:${account}`;
+const size = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+/**
+ * What makes an event the next meeting: timed, not cancelled, not declined by the owner, an ordinary event (no focus
+ * time, out-of-office or working location), and someone other than the owner and the rooms invited.
+ */
+const isMeeting = (details) => {
+    if (details.event.allDay || details.event.status === "cancelled")
+        return false;
+    const live = details.entries.filter((entry) => entry.deletedAt === null && entry.status !== "cancelled");
+    if (!live.length || live.every((entry) => entry.ownResponse === "declined"))
+        return false;
+    if (live.every((entry) => entry.eventType !== null && entry.eventType !== "default"))
+        return false;
+    return details.participants.some((one) => !one.self && !one.resource);
+};
+/** The account's next meeting that has not started yet, by the rule of `isMeeting`. */
+export const nextMeeting = async (store, accountId, now) => {
+    for (let offset = 0; offset < NEXT_SCAN; offset += NEXT_PAGE) {
+        const page = await store.events({ accountId, startsFrom: now, limit: NEXT_PAGE, offset });
+        for (const one of page) {
+            if (one.allDay || one.status === "cancelled")
+                continue;
+            const details = await eventOf(store, accountId, one.id).catch(() => undefined);
+            if (details && isMeeting(details))
+                return details;
+        }
+        if (page.length < NEXT_PAGE)
+            break;
+    }
+    throw new CliError("not_found", "no upcoming meeting with other attendees in the store; run sync, or name an event", {
+        reason: "calendar.no-upcoming",
+    });
+};
+const UNTRUSTED = [
+    ...CALENDAR_UNTRUSTED_FIELDS.filter((field) => !["candidates.title", "entry.title", "ended.title"].includes(field)).map((field) => `event.${field}`),
+    "people.name",
+    ...["direct", "groups"].flatMap((list) => ["chat_title", "sender_name", "text"].map((field) => `people.recent.${list}.${field}`)),
+    "people.past_events.title",
+    "people.past_events.location",
+    "people.meetings.cues.speaker_name",
+    "people.meetings.cues.text",
+];
+/**
+ * The stored evidence for one meeting: the event, and for each attendee other than the owner, their linked identities,
+ * their latest messages and mail, the events and recorded meetings they shared with the owner. Reads the store only,
+ * every account that saw each person (WC-ACCT-9), and writes nothing; the brief is the agent's.
+ */
+export const eventPreparation = async (details, options) => {
+    const { messages: store, account, personOf, now, since } = options;
+    const limit = options.limit ?? PREPARE_MESSAGES;
+    const shown = await eventAnswer(details, personOf);
+    const others = shown.attendees
+        .filter((one) => !one.self && !one.resource)
+        .sort((a, b) => Number(b.organizer) - Number(a.organizer));
+    const read = new Map([[nameOf(account.key), account.key]]);
+    const issues = [];
+    const stored = await store.accounts.storedAccounts();
+    let left = PREPARE_BYTES - size(shown);
+    let truncated = others.length > PREPARE_PEOPLE;
+    let pending = 0;
+    const people = [];
+    for (const [index, attendee] of others.entries()) {
+        const base = {
+            email: attendee.email,
+            name: attendee.name,
+            response: attendee.response,
+            organizer: attendee.organizer,
+            optional: attendee.optional,
+            person: attendee.person,
+        };
+        const record = attendee.person ? await store.people.personOf({ provider: "email", id: attendee.email }) : undefined;
+        const nothing = {
+            ...base,
+            read: false,
+            identities: record ? record.identities.map(({ provider, id }) => `${provider}:${id}`) : [],
+            recent: { direct: [], groups: [] },
+            pastEvents: [],
+            meetings: [],
+            hasMore: false,
+        };
+        if (!record || index >= PREPARE_PEOPLE || left < 2048) {
+            if (record && index < PREPARE_PEOPLE)
+                truncated = true;
+            people.push(nothing);
+            continue;
+        }
+        const reads = readsOf(record, account.key);
+        for (const { key } of reads)
+            read.set(nameOf(key), key);
+        const context = await recordContext(store, record, reads, {
+            messages: limit,
+            bytes: Math.min(left, PERSON_BYTES),
+            now,
+            ...(since === undefined ? {} : { since }),
+        });
+        for (const chat of context.notRead)
+            issues.push({
+                code: "not_found",
+                reason: "chat.not-read",
+                source: `${chat.provider}:${chat.account}/${chat.chatId}`,
+            });
+        const meetings = await meetingsWith(store, record.uid, stored, since);
+        pending = Math.max(pending, meetings.pending);
+        for (const id of meetings.accounts) {
+            const one = stored.find((held) => held.id === id);
+            if (one)
+                read.set(nameOf(one), { provider: one.provider, account: one.account });
+        }
+        const entry = {
+            ...nothing,
+            read: true,
+            recent: context.recent,
+            pastEvents: context.events.recent.filter((one) => one.ref !== shown.ref).slice(0, limit),
+            meetings: meetings.items,
+            hasMore: context.hasMore || meetings.hasMore,
+        };
+        left -= size(entry);
+        people.push(entry);
+    }
+    if (pending > 0)
+        issues.push({ code: "not_found", reason: "meetings.index-pending", source: "meetings" });
+    const calendar = await accountsMeta(options.store, [account], [], now);
+    const all = [...(calendar.issues ?? []), ...issues];
+    const meta = {
+        accounts: [...read.keys()],
+        complete: all.length === 0,
+        ...(all.length ? { issues: all } : {}),
+        ...(truncated || left < 0 ? { truncated: true } : {}),
+    };
+    return {
+        event: shown,
+        people,
+        limits: { people: PREPARE_PEOPLE, messages: limit, bytes: PREPARE_BYTES },
+        untrusted: UNTRUSTED,
+        meta,
+    };
+};
+/** Their latest recorded meetings in every stored account that saw them; none is not an error. */
+const meetingsWith = async (store, uid, stored, since) => {
+    const none = { items: [], hasMore: false, accounts: [], pending: 0 };
+    if (!stored.length)
+        return none;
+    try {
+        const found = await personMeetingContext(store, `person:${uid}`, {
+            accountIds: stored.slice(0, 1000).map(({ id }) => id),
+            meetings: MEETINGS,
+            cues: CUES,
+            bytes: PERSON_BYTES,
+            ...(since === undefined ? {} : { since }),
+        });
+        return {
+            items: found.items,
+            hasMore: found.coverage.truncatedBy !== null || found.coverage.scanLimitReached,
+            accounts: [...new Set(found.items.map((item) => parseMeetingReference(item.reference).accountId))],
+            pending: found.coverage.pending,
+        };
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === "not_found")
+            return none;
+        throw error;
+    }
+};