@wirecat/cli-core 0.487.0 → 0.489.0

package/dist/meetings/event-store.js

@@ -1 +1,65 @@
-export {};
+const UNTIL = /(?:^|;)UNTIL=(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?(?:;|$)/iu;
+/** The last moment a series can have a slot, when its rule says; a COUNT rule or none repeats as far as this knows. */
+const seriesEnd = (entry) => {
+    if (entry.recurrenceEndsAt !== null)
+        return entry.recurrenceEndsAt;
+    const rule = entry.recurrence?.find((line) => /^RRULE:/iu.test(line));
+    const until = rule === undefined ? null : UNTIL.exec(rule.slice("RRULE:".length));
+    if (!until)
+        return Number.POSITIVE_INFINITY;
+    const [, year, month, day, hour = "23", minute = "59", second = "59"] = until;
+    // A floating or zoned UNTIL is read as UTC; a day later keeps a series near the edge counted as inside.
+    return (Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second)) + 86_400_000);
+};
+/**
+ * Whether a full list of the window would return the entry: a single or a moved slot by its own time, a plain slot by
+ * the time its series gave it, a series while it repeats into the window. An entry with no time is never counted.
+ */
+export const entryInWindow = (entry, window) => {
+    if (entry.kind === "occurrence" && !entry.exception)
+        return (entry.originalStartsAt !== null && entry.originalStartsAt >= window.from && entry.originalStartsAt < window.to);
+    const start = entry.startsAt ?? (entry.kind === "occurrence" ? entry.originalStartsAt : null);
+    if (start === null || start >= window.to)
+        return false;
+    if (entry.kind === "series")
+        return seriesEnd(entry) >= window.from;
+    return Math.max(entry.endsAt ?? start, start + 1) > window.from;
+};
+/**
+ * The event's change since `since`, from its copies and their revisions (each revision holds the fields before one
+ * change): cancelled when the event is gone and a copy was cancelled or removed since; new when its first copy was
+ * stored since; moved when a live copy's time now differs from its time at `since`. `null` when none of these.
+ */
+export const eventChange = (event, entries, revisions, since) => {
+    const after = (entryId) => revisions
+        .filter((one) => one.entryId === entryId && one.createdAt >= since)
+        .sort((a, b) => a.createdAt - b.createdAt);
+    if (event.status === "cancelled" || event.sourceDeletedAt !== null) {
+        const times = entries.flatMap((entry) => [
+            ...(entry.deletedAt !== null && entry.deletedAt >= since ? [entry.deletedAt] : []),
+            ...(entry.status === "cancelled"
+                ? after(entry.id)
+                    .filter((one) => one.status !== "cancelled")
+                    .map(({ createdAt }) => createdAt)
+                : []),
+        ]);
+        if (times.length)
+            return { change: "cancelled", at: Math.max(...times) };
+    }
+    const first = Math.min(...entries.map(({ createdAt }) => createdAt));
+    if (entries.length && first >= since)
+        return { change: "new", at: first };
+    for (const entry of entries) {
+        if (entry.deletedAt !== null || entry.status === "cancelled")
+            continue;
+        const changes = after(entry.id);
+        const [was] = changes;
+        if (was && (was.startsAt !== entry.startsAt || was.endsAt !== entry.endsAt))
+            return {
+                change: "moved",
+                at: changes.at(-1).createdAt,
+                was: { startsAt: was.startsAt, endsAt: was.endsAt },
+            };
+    }
+    return null;
+};

package/dist/meetings/index.d.ts

@@ -4,7 +4,8 @@ export { calendarText, ENTRY_METADATA_KEYS, entryMetadata, withoutLinkQueries }
 export type { MeetingContextStore, MeetingEventLinkInput, MeetingEventLinkReceipt, ParticipantPerson, ParticipantPersonInput, ParticipantPersonLinkInput, ParticipantPersonLinkReceipt, } from "./context-store.js";
 export { type MeetingCueIdentity, meetingCueFingerprint } from "./cue-fingerprint.js";
 export { EVENT_QUERY } from "./event-query.js";
-export type { CalendarAccessRole, CalendarInput, EntryAttachment, EntryAttachmentInput, EntryEventType, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EntryTransparency, EntryVisibility, EventDetails, EventFilter, EventStore, LinkReview, ParticipantResponse, ReviewDecision, StoredCalendar, StoredEntry, StoredParticipant, } from "./event-store.js";
+export type { CalendarAccessRole, CalendarInput, EntryAttachment, EntryAttachmentInput, EntryEventType, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EntryTransparency, EntryVisibility, EventChange, EventDetails, EventFilter, EventStore, LinkReview, ParticipantResponse, ReviewDecision, SeriesSlots, StoredCalendar, StoredEntry, StoredParticipant, } from "./event-store.js";
+export { entryInWindow, eventChange } from "./event-store.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, type MeetingExport, type MeetingExportFormat, type MeetingExportOptions, serializeVtt, } from "./export.js";
 export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDINGS_KIND, type MeetingFactFinding, type MeetingFinding, type MeetingFindingsInput, type MeetingFindingsReceipt, type MeetingTaskFinding, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";

package/dist/meetings/index.js

@@ -2,6 +2,7 @@ export { MEETING_STEPS, meetingDetails, meetingHit, meetingHitsList, meetingSumm
 export { calendarText, ENTRY_METADATA_KEYS, entryMetadata, withoutLinkQueries } from "./calendar-text.js";
 export { meetingCueFingerprint } from "./cue-fingerprint.js";
 export { EVENT_QUERY } from "./event-query.js";
+export { entryInWindow, eventChange } from "./event-store.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, serializeVtt, } from "./export.js";
 export { findingHash, MEETING_FINDINGS_KIND, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";

package/dist/meetings/testing/event-store-contract.d.ts

@@ -1,4 +1,4 @@
-import type { EventStore } from "../event-store.js";
+import { type EventStore } from "../event-store.js";
 import type { ContractCase } from "../store.js";
 /** A fresh, empty store and one calendar account in it. */
 export interface EventStoreFixture {

package/dist/meetings/testing/event-store-contract.js

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { eventChange } from "../event-store.js";
 const HOUR = 3_600_000;
 /** "Now" in every case: entries before it have happened. */
 export const CONTRACT_NOW = 1_000 * HOUR;
@@ -218,6 +219,119 @@ export const eventStoreContract = (make) => {
             assert.equal((await store.event(kept?.eventId))?.entries[0]?.deletedAt, null);
             assert.equal((await store.event(far?.eventId))?.entries[0]?.deletedAt, null);
         }),
+        test("a full list marks nothing outside its window: a single, a moved slot, a series that ended", async ({ store, calendar, }) => {
+            const month = 30 * 24 * HOUR;
+            const until = new Date(earlier - month).toISOString().replace(/[-:]|\.\d{3}/gu, "");
+            await store.saveEntries(calendar, [
+                single("old", earlier - month),
+                single("next", later + month),
+                single("inside", later),
+                single("ended", earlier - 2 * month, { kind: "series", recurrence: [`RRULE:FREQ=WEEKLY;UNTIL=${until}`] }),
+                single("endless", earlier - 2 * month, { kind: "series", recurrence: ["RRULE:FREQ=WEEKLY"] }),
+                single("moved", earlier - month, {
+                    kind: "occurrence",
+                    exception: true,
+                    seriesExternalId: "endless",
+                    originalStartsAt: earlier - month,
+                }),
+            ], 2);
+            assert.equal(await store.markUnseen(calendar, 10, { from: earlier, to: later + 24 * HOUR }, 11), 2);
+            const deleted = async (id) => (await store.entry(calendar, id))?.deletedAt;
+            assert.deepEqual(await Promise.all(["old", "next", "ended", "moved", "inside", "endless"].map(deleted)), [
+                null,
+                null,
+                null,
+                null,
+                11,
+                11,
+            ]);
+        }),
+        test("entries marked outside the window of the list that marked them come back, with their events", async ({ store, calendar, }) => {
+            const month = 30 * 24 * HOUR;
+            const [old, next, inside] = await store.saveEntries(calendar, [single("old", earlier - month), single("next", later + month), single("inside", later)], 2);
+            assert.equal(await store.markUnseen(calendar, 10, { from: 0, to: later + 2 * month }, 11), 3);
+            assert.equal((await store.event(next?.eventId))?.event.status, "cancelled");
+            assert.equal(await store.restoreUnseen(calendar, () => ({ from: earlier, to: later + 24 * HOUR }), 12), 2);
+            const oldEvent = (await store.event(old?.eventId))?.event;
+            const nextEvent = (await store.event(next?.eventId))?.event;
+            assert.equal(oldEvent?.sourceDeletedAt, null);
+            assert.equal(nextEvent?.status, "confirmed");
+            assert.equal((await store.entry(calendar, "old"))?.deletedAt, null);
+            assert.equal((await store.entry(calendar, "inside"))?.deletedAt, 11);
+            assert.equal(await store.restoreUnseen(calendar, () => ({ from: earlier, to: later + 24 * HOUR }), 13), 0);
+            assert.equal((await store.event(inside?.eventId))?.event.status, "cancelled");
+        }),
+        test("a list by time finds a long event that started well before it, timed or all-day", async ({ store, calendar, }) => {
+            const day = 24 * HOUR;
+            await store.saveEntries(calendar, [
+                single("trip", later - 30 * day, { endsAt: later + 30 * day }),
+                single("leave", later - 30 * day, {
+                    allDay: true,
+                    startDate: new Date(later - 30 * day).toISOString().slice(0, 10),
+                    endDate: new Date(later + 30 * day).toISOString().slice(0, 10),
+                    endsAt: later + 30 * day,
+                }),
+                single("today", later),
+            ], 2);
+            const day0 = new Date(later).toISOString().slice(0, 10);
+            const day1 = new Date(later + day).toISOString().slice(0, 10);
+            for (const filter of [
+                { from: later, to: later + day },
+                { from: later, to: later + day, fromDate: day0, toDate: day1 },
+            ])
+                assert.deepEqual((await store.events(filter)).map(({ title }) => title).length, 3, JSON.stringify(filter));
+        }),
+        test("a list of changes since an instant finds events new, moved or cancelled since, and says which", async ({ store, calendar, }) => {
+            await store.saveEntries(calendar, ["same", "moved", "back", "cancelled"].map((id) => single(id, later)), 2);
+            await store.saveEntries(calendar, [
+                single("moved", later + HOUR),
+                single("back", later + HOUR),
+                single("cancelled", later, { status: "cancelled" }),
+                single("new", later),
+            ], 10);
+            await store.saveEntries(calendar, [single("back", later)], 11);
+            const changed = async (since) => {
+                const events = await store.events({ changedSince: since });
+                const { entries, revisions } = await store.historyOf(events.map(({ id }) => id), [calendar], since);
+                return Object.fromEntries(events.map((event) => {
+                    const [copy] = entries.filter(({ eventId }) => eventId === event.id);
+                    return [
+                        copy?.externalId,
+                        eventChange(event, entries.filter(({ eventId }) => eventId === event.id), revisions, since),
+                    ];
+                }));
+            };
+            assert.deepEqual(await changed(5), {
+                moved: { change: "moved", at: 10, was: { startsAt: later, endsAt: later + HOUR } },
+                cancelled: { change: "cancelled", at: 10 },
+                new: { change: "new", at: 10 },
+            });
+            assert.deepEqual(Object.keys(await changed(12)), []);
+            assert.equal((await changed(1)).same?.change, "new");
+        }),
+        test("a list of overlapping events holds timed events that clash and take the owner's time", async ({ store, calendar, }) => {
+            const at = later;
+            await store.saveEntries(calendar, [
+                single("first", at),
+                single("second", at + HOUR / 2),
+                single("alone", at + 3 * HOUR),
+                single("declined", at + 3 * HOUR + HOUR / 2, { ownResponse: "declined" }),
+                single("busy", at + 5 * HOUR),
+                single("free", at + 5 * HOUR, { transparency: "transparent" }),
+                single("cancelled", at + 3 * HOUR, { status: "cancelled" }),
+                single("all-day", at, {
+                    allDay: true,
+                    startDate: new Date(at).toISOString().slice(0, 10),
+                    endDate: new Date(at + 24 * HOUR).toISOString().slice(0, 10),
+                    endsAt: at + 24 * HOUR,
+                }),
+            ], 2);
+            const found = await store.events({ overlapping: true, from: at - HOUR, to: at + 8 * HOUR });
+            assert.deepEqual(found.map(({ title }) => title).length, 2);
+            const ids = new Set(found.map(({ id }) => id));
+            for (const externalId of ["first", "second"])
+                assert.ok(ids.has((await store.entry(calendar, externalId))?.eventId), externalId);
+        }),
         test("participants are kept by address; a room is listed and is no contact", async ({ store, calendar }) => {
             const [entry] = await store.saveEntries(calendar, [
                 single("a", later, {

package/dist/store/drivers/node-sqlite.d.ts

@@ -9,4 +9,12 @@ export declare const openWithNodeSqlite: (path: string) => Promise<CacheDatabase
 export declare const nodeClient: (path: string, { readOnly }?: {
     readOnly?: boolean;
 }) => Promise<DatabaseSync>;
-export declare const cacheOverNodeSqlite: (database: DatabaseSync) => CacheDatabase;
+/**
+ * Preparing is the expensive part of a call: the sync write path builds the same SQL text thousands of times, so each
+ * connection keeps its statements, least recently used out first. Node's own `createTagStore` would do it, but it needs
+ * Node 24.9 and template tags, not SQL text. An evicted statement is not finalized, because a caller may still hold
+ * it; `close()` finalizes everything left. The seam must never offer `iterate`: callers share a cached statement, and
+ * reusing a statement invalidates its open iterator.
+ */
+export declare const STATEMENT_CACHE_SIZE = 1000;
+export declare const cacheOverNodeSqlite: (database: DatabaseSync, cacheSize?: number) => CacheDatabase;

package/dist/store/drivers/node-sqlite.js

@@ -19,17 +19,39 @@ export const nodeClient = async (path, { readOnly = false } = {}) => {
         throw error;
     }
 };
-export const cacheOverNodeSqlite = (database) => {
+/**
+ * Preparing is the expensive part of a call: the sync write path builds the same SQL text thousands of times, so each
+ * connection keeps its statements, least recently used out first. Node's own `createTagStore` would do it, but it needs
+ * Node 24.9 and template tags, not SQL text. An evicted statement is not finalized, because a caller may still hold
+ * it; `close()` finalizes everything left. The seam must never offer `iterate`: callers share a cached statement, and
+ * reusing a statement invalidates its open iterator.
+ */
+export const STATEMENT_CACHE_SIZE = 1000;
+export const cacheOverNodeSqlite = (database, cacheSize = STATEMENT_CACHE_SIZE) => {
+    const statements = new Map();
+    const prepare = (sql) => {
+        const statement = database.prepare(sql);
+        return {
+            run: (...parameters) => ({ changes: Number(statement.run(...parameters).changes) }),
+            get: (...parameters) => statement.get(...parameters),
+            all: (...parameters) => statement.all(...parameters),
+        };
+    };
     return {
         exec: (sql) => database.exec(sql),
         prepare: (sql) => {
-            const statement = database.prepare(sql);
-            return {
-                run: (...parameters) => ({ changes: Number(statement.run(...parameters).changes) }),
-                get: (...parameters) => statement.get(...parameters),
-                all: (...parameters) => statement.all(...parameters),
-            };
+            const cached = statements.get(sql);
+            if (cached)
+                statements.delete(sql);
+            const statement = cached ?? prepare(sql);
+            statements.set(sql, statement);
+            if (statements.size > cacheSize)
+                statements.delete(statements.keys().next().value);
+            return statement;
+        },
+        close: () => {
+            statements.clear();
+            database.close();
         },
-        close: () => database.close(),
     };
 };

package/dist/store/index.d.ts

@@ -29,7 +29,7 @@ export type { BotUpdate, BotUpdateStore } from "./sqlite/bot-updates.js";
 export type { CatalogActor, CatalogEntry, CatalogInput, CatalogQuery, CatalogStore } from "./sqlite/catalog.js";
 export { CATALOG_QUERY } from "./sqlite/catalog.js";
 export type { ChatMetadata } from "./sqlite/chats.js";
-export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
+export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailLocationInput, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, FolderEmail, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
 export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
 export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";

package/dist/store/sqlite/accounts.js

@@ -92,6 +92,7 @@ export const purgeAccount = ({ orm, database }, accountKey) => {
     orm.delete(messages).where(eq(messages.accountId, accountKey)).run();
     orm.delete(chats).where(eq(chats.accountId, accountKey)).run();
     orm.delete(syncCursors).where(eq(syncCursors.accountId, accountKey)).run();
+    orm.run(sql `DELETE FROM email_locations WHERE mailbox_id IN (SELECT id FROM mailboxes WHERE account_id = ${accountKey})`);
     // Deleting an email clears its recipients, mailboxes, words, attachments and tags (trigger email_bd).
     orm.run(sql `DELETE FROM emails WHERE account_id = ${accountKey}`);
     orm.run(sql `DELETE FROM taggings WHERE taggable_type = 'email_thread' AND taggable_id IN (SELECT id FROM email_threads WHERE account_id = ${accountKey})`);

package/dist/store/sqlite/calendar-events.d.ts

@@ -0,0 +1,4 @@
+import type { Event, EventFilter } from "../../meetings/index.js";
+import type { CacheDatabase } from "../driver.js";
+/** The events of a filter, earliest first (`EventStore.events`). */
+export declare const listEvents: (database: CacheDatabase, filter: EventFilter) => Event[];

package/dist/store/sqlite/calendar-events.js

@@ -0,0 +1,89 @@
+import { CliError } from "@wirecat/cli-base";
+import { eventOf } from "./events.js";
+const DAY = 86_400_000;
+/** The events of a filter, earliest first (`EventStore.events`). */
+export const listEvents = (database, filter) => {
+    const clauses = ["e.deleted_at IS NULL"];
+    const params = [];
+    const entries = (extra) => `EXISTS (SELECT 1 FROM calendar_entries ce JOIN calendars c ON c.id = ce.calendar_id WHERE ce.event_id = e.id AND ${extra})`;
+    const dated = (column, date, instant, at) => {
+        if (at === undefined)
+            return;
+        if (date === undefined) {
+            clauses.push(instant);
+            params.push(at);
+            return;
+        }
+        clauses.push(`(CASE WHEN e.all_day = 1 THEN EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id AND ce.${column}) ELSE ${instant} END)`);
+        params.push(date, at);
+    };
+    dated("end_date > ?", filter.fromDate, "coalesce(e.ends_at, e.starts_at + 1) > ?", filter.from);
+    dated("start_date < ?", filter.toDate, "e.starts_at < ?", filter.to);
+    // Bounds on starts_at alone let SQLite seek its index; the CASE above cannot. They are wider than the CASE: by the
+    // longest stored event back, and by a day each way for an all-day event's zone.
+    const longest = () => Number(database.prepare("SELECT coalesce(max(ends_at - starts_at), 0) AS ms FROM events WHERE deleted_at IS NULL").get()
+        ?.ms ?? 0);
+    if (filter.from !== undefined) {
+        clauses.push("e.starts_at >= ?");
+        params.push(filter.from - longest() - DAY);
+    }
+    if (filter.to !== undefined && filter.toDate !== undefined) {
+        clauses.push("e.starts_at < ?");
+        params.push(filter.to + DAY);
+    }
+    if (filter.calendarId !== undefined) {
+        clauses.push(entries("ce.calendar_id = ?"));
+        params.push(filter.calendarId);
+    }
+    if (filter.accountId !== undefined) {
+        clauses.push(entries("c.account_id = ?"));
+        params.push(filter.accountId);
+    }
+    if (filter.personId !== undefined) {
+        clauses.push(entries("EXISTS (SELECT 1 FROM calendar_entry_participants p JOIN identity_links il ON il.identity_id = p.identity_id " +
+            "WHERE p.entry_id = ce.id AND il.person_id = ?)"));
+        params.push(filter.personId);
+    }
+    const account = (alias) => {
+        if (filter.accountId === undefined)
+            return "";
+        params.push(filter.accountId);
+        return ` AND ${alias}.account_id = ?`;
+    };
+    if (filter.changedSince !== undefined) {
+        // The SQL form of eventChange: first stored since, cancelled since, or a live copy's time changed since.
+        const since = filter.changedSince;
+        const own = account("c");
+        params.push(since);
+        const older = account("oc");
+        params.push(since, since, since, since);
+        clauses.push(`EXISTS (SELECT 1 FROM calendar_entries ce JOIN calendars c ON c.id = ce.calendar_id WHERE ce.event_id = e.id${own}
+         AND ((ce.created_at >= ? AND NOT EXISTS (SELECT 1 FROM calendar_entries o JOIN calendars oc
+                 ON oc.id = o.calendar_id WHERE o.event_id = e.id${older} AND o.created_at < ?))
+           OR ((e.status = 'cancelled' OR e.source_deleted_at IS NOT NULL) AND (ce.deleted_at >= ?
+             OR (ce.status = 'cancelled' AND EXISTS (SELECT 1 FROM calendar_entry_revisions r WHERE r.entry_id = ce.id
+               AND r.created_at >= ? AND r.status IS NOT 'cancelled'))))
+           OR (ce.deleted_at IS NULL AND ce.status <> 'cancelled' AND (SELECT r.starts_at IS NOT ce.starts_at
+             OR r.ends_at IS NOT ce.ends_at FROM calendar_entry_revisions r WHERE r.entry_id = ce.id AND r.created_at >= ?
+             ORDER BY r.created_at, r.id LIMIT 1) = 1)))`);
+    }
+    if (filter.overlapping) {
+        const busy = (event) => `${event}.deleted_at IS NULL AND ${event}.status <> 'cancelled' AND ${event}.all_day = 0
+         AND ${event}.starts_at IS NOT NULL AND ${event}.ends_at IS NOT NULL AND EXISTS (SELECT 1 FROM calendar_entries
+           bce JOIN calendars bc ON bc.id = bce.calendar_id WHERE bce.event_id = ${event}.id${account("bc")}
+           AND bce.deleted_at IS NULL AND bce.status <> 'cancelled' AND coalesce(bce.own_response, '') <> 'declined'
+           AND coalesce(bce.transparency, '') <> 'transparent')`;
+        const own = busy("e");
+        params.push(longest());
+        clauses.push(`${own} AND EXISTS (SELECT 1 FROM events e2 WHERE e2.id <> e.id AND e2.starts_at < e.ends_at
+         AND e2.ends_at > e.starts_at AND e2.starts_at >= e.starts_at - ? AND ${busy("e2")})`);
+    }
+    const limit = filter.limit ?? 100;
+    const offset = filter.offset ?? 0;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(offset) || offset < 0)
+        throw new CliError("validation_error", "limit takes 1–1000 and offset 0 or more");
+    return database
+        .prepare(`SELECT e.* FROM events e WHERE ${clauses.join(" AND ")} ORDER BY ${filter.newest ? "e.starts_at DESC, e.id DESC" : "e.starts_at, e.id"} LIMIT ? OFFSET ?`)
+        .all(...params, limit, offset)
+        .map(eventOf);
+};