@wirecat/cli-core 0.419.0 → 0.421.0

package/dist/store/sqlite/chats.js

@@ -425,7 +425,7 @@ export const replaceAutoTags = (context, key, chatId, algorithm, matches) => {
     const pk = metadataChatPk(context, key, chatId);
     const db = context.database;
     db.prepare("DELETE FROM taggings WHERE taggable_type='chat' AND taggable_id=? AND source='auto'").run(pk);
-    db.prepare("DELETE FROM auto_tag_claims WHERE chat_id=?").run(pk);
+    db.prepare("DELETE FROM canonical_auto_tag_claims WHERE chat_id=?").run(pk);
     const claims = new Map();
     for (const match of matches) {
         const tagId = ensureTag(context, match.tag).id;
@@ -436,7 +436,7 @@ export const replaceAutoTags = (context, key, chatId, algorithm, matches) => {
         });
     }
     for (const [tagId, match] of claims) {
-        db.prepare("INSERT INTO auto_tag_claims (chat_id, tag_id, algorithm, score, fields, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(pk, tagId, algorithm, match.score, JSON.stringify(match.fields), context.now(), context.now());
+        db.prepare("INSERT INTO canonical_auto_tag_claims (chat_id, tag_id, algorithm, score, fields, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(pk, tagId, algorithm, match.score, JSON.stringify(match.fields), context.now(), context.now());
         db.prepare("INSERT INTO taggings (tag_id, taggable_type, taggable_id, source, created_at, updated_at) VALUES (?, 'chat', ?, 'auto', ?, ?) ON CONFLICT DO NOTHING").run(tagId, pk, context.now(), context.now());
     }
 };

package/dist/store/sqlite/context-document-source.js

@@ -1,9 +1,13 @@
-// Existing Drive file-note imports keep this provenance in front matter; never hydrate the whole blob.
+import { PREFERRED_FILE } from "./files.js";
+// A document's preferred file holds its link and edit time; rows without one keep them in front matter.
 const drive = "CASE WHEN json_valid(n.front_matter) THEN json_extract(n.front_matter,'$.source')='google-drive' ELSE 0 END";
 const field = (name) => `CASE WHEN (${drive}) THEN
   CASE WHEN json_type(n.front_matter,'$.${name}')='text' THEN json_extract(n.front_matter,'$.${name}') END END`;
+const preferred = (column) => `(SELECT f.${column} FROM files f JOIN documents d ON d.id = f.document_id WHERE f.document_id = n.id
+    ORDER BY ${PREFERRED_FILE} LIMIT 1)`;
 const modified = `round(unixepoch(${field("modifiedAt")},'subsec')*1000)`;
-export const contextDocumentTime = `coalesce(n.external_updated_at,${modified},n.updated_at)`;
-export const contextDocumentTimeKind = `CASE WHEN n.external_updated_at IS NOT NULL OR (${modified}) IS NOT NULL
+const remoteTime = `coalesce(${preferred("external_updated_at")},n.external_updated_at,${modified})`;
+export const contextDocumentTime = `coalesce(${remoteTime},n.updated_at)`;
+export const contextDocumentTimeKind = `CASE WHEN (${remoteTime}) IS NOT NULL
   THEN 'source-modified' ELSE 'stored-update' END`;
-export const contextDocumentUrl = `coalesce(n.url,${field("sourceUrl")})`;
+export const contextDocumentUrl = `coalesce(${preferred("url")},n.url,${field("sourceUrl")})`;

package/dist/store/sqlite/document-transfer/apply.js

@@ -1,11 +1,27 @@
 import { CliError } from "@wirecat/cli-base";
+import { folderProviderOf } from "../../../domain/providers.js";
 import { botNamed, ownerPerson } from "../actors.js";
+import { syncFile } from "../files.js";
 import { canonicalTagNamed } from "../tags.js";
 import { referenceOfThing } from "../things.js";
 import { write } from "../transaction.js";
 import { copyPeople } from "./people.js";
 import { planTransfer } from "./plan.js";
 import { TRANSFER_TABLES } from "./snapshot.js";
+/** A file exported before store version 32 names its folder `folder`; here it gets the provider its format says. */
+const providerHere = ({ provider, name, settings }) => {
+    if (provider !== "folder" || String(name ?? "").startsWith("google-drive:"))
+        return provider ?? null;
+    return folderProviderOf(formatOf(settings) === "markdown" ? "markdown" : "obsidian");
+};
+const formatOf = (settings) => {
+    try {
+        return JSON.parse(String(settings))?.format;
+    }
+    catch {
+        return undefined;
+    }
+};
 const COLUMNS = {
     document: "account_id external_id kind title location file_name extension url storage local_path mime size content_hash front_matter body normalized_text extraction extraction_error language revision export_path external_created_at external_updated_at metadata created_at updated_at deleted_at",
     note: "notable_type notable_id title body author_type author_id revision created_at updated_at deleted_at",
@@ -54,7 +70,11 @@ export const applyTransfer = (database, snapshot, sourceKey, bindings, expectedF
         const organization = snapshot.collection.organization_id == null
             ? undefined
             : mapped(mappings, "organization", snapshot.collection.organization_id);
-        collectionId = insert(database, "accounts", "provider external_id name created_at settings updated_at scope organization_id", { ...snapshot.collection, organization_id: organization?.id ?? null });
+        collectionId = insert(database, "accounts", "provider external_id name created_at settings updated_at scope organization_id", {
+            ...snapshot.collection,
+            provider: providerHere(snapshot.collection),
+            organization_id: organization?.id ?? null,
+        });
     }
     mappings.set(`account:${String(snapshot.collection.id)}`, { type: "account", id: collectionId });
     const inserted = new Set();
@@ -79,6 +99,8 @@ export const applyTransfer = (database, snapshot, sourceKey, bindings, expectedF
                 values.project_id = null;
         }
         const id = insert(database, TRANSFER_TABLES[entity.kind], COLUMNS[entity.kind], values);
+        if (entity.kind === "document")
+            syncFile(database, now(), id, { seen: false });
         mappings.set(entity.key, { type: entity.kind, id });
         inserted.add(entity.key);
     }
@@ -105,7 +127,7 @@ export const applyTransfer = (database, snapshot, sourceKey, bindings, expectedF
         const tag = canonicalTagNamed(database, String(tagging.tag_name));
         const tagId = tag
             ? Number(tag.id)
-            : insert(database, "tags", "name kind created_at updated_at", {
+            : insert(database, "canonical_tags", "name kind created_at updated_at", {
                 name: tagging.tag_name ?? null,
                 kind: tagging.tag_kind ?? null,
                 created_at: tagging.created_at ?? null,

package/dist/store/sqlite/document-transfer/collection.d.ts

@@ -0,0 +1,19 @@
+import type { CacheDatabase } from "../../driver.js";
+type Row = Record<string, unknown>;
+/**
+ * The name a transfer gives a collection. A Drive collection is `google-drive:<principal>` before version 31 (the
+ * stand-in folder's name) and after it (the account's key), so transfers between stores on either side still match.
+ */
+export declare const collectionNameOf: (row: Row) => string;
+/** At most two rows: the account a collection name stands for, and a second one only when that is ambiguous. */
+export declare const collectionAccounts: (database: CacheDatabase, collection: string) => Row[];
+/** The stand-in folder version 31 moved an account's documents from, as its `settings.movedFrom` records it. */
+export declare const movedFromOf: (row: Row | undefined) => {
+    external_id?: unknown;
+} | undefined;
+/**
+ * A source store from before version 31 holds Drive in a `folder` named `google-drive:<principal>`; the copy gets the
+ * shape version 31 gives it, so it lands in (or creates) the `google-drive` account, never a new stand-in folder.
+ */
+export declare const currentCollection: (row: Row) => Row;
+export {};

package/dist/store/sqlite/document-transfer/collection.js

@@ -0,0 +1,66 @@
+import { folderProviderSql, isDocumentAccountProvider } from "../../../domain/providers.js";
+/** `google-drive:<principal>` names a documents account; anything else is a notes folder's name. */
+const documentsKeyOf = (collection) => {
+    const colon = collection.indexOf(":");
+    const provider = collection.slice(0, colon);
+    return colon > 0 && isDocumentAccountProvider(provider)
+        ? { provider, account: collection.slice(colon + 1) }
+        : undefined;
+};
+/**
+ * The name a transfer gives a collection. A Drive collection is `google-drive:<principal>` before version 31 (the
+ * stand-in folder's name) and after it (the account's key), so transfers between stores on either side still match.
+ */
+export const collectionNameOf = (row) => isDocumentAccountProvider(String(row.provider))
+    ? `${String(row.provider)}:${String(row.external_id)}`
+    : String(row.name);
+/** At most two rows: the account a collection name stands for, and a second one only when that is ambiguous. */
+export const collectionAccounts = (database, collection) => {
+    const key = documentsKeyOf(collection);
+    return key
+        ? database
+            .prepare(`SELECT * FROM accounts WHERE (provider=? AND external_id=?) OR (${folderProviderSql()} AND name=?) ORDER BY id LIMIT 2`)
+            .all(key.provider, key.account, collection)
+        : database
+            .prepare(`SELECT * FROM accounts WHERE ${folderProviderSql()} AND name=? ORDER BY id LIMIT 2`)
+            .all(collection);
+};
+/** The stand-in folder version 31 moved an account's documents from, as its `settings.movedFrom` records it. */
+export const movedFromOf = (row) => {
+    if (typeof row?.settings !== "string")
+        return undefined;
+    try {
+        const moved = JSON.parse(row.settings).movedFrom;
+        return typeof moved === "object" && moved !== null ? moved : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * A source store from before version 31 holds Drive in a `folder` named `google-drive:<principal>`; the copy gets the
+ * shape version 31 gives it, so it lands in (or creates) the `google-drive` account, never a new stand-in folder.
+ */
+export const currentCollection = (row) => {
+    const key = isDocumentAccountProvider(String(row.provider)) ? undefined : documentsKeyOf(String(row.name));
+    if (!key)
+        return row;
+    const settings = (() => {
+        try {
+            return typeof row.settings === "string" ? JSON.parse(row.settings) : {};
+        }
+        catch {
+            return {};
+        }
+    })();
+    return {
+        ...row,
+        provider: key.provider,
+        external_id: key.account,
+        name: "Google Drive",
+        settings: JSON.stringify({
+            ...settings,
+            movedFrom: { id: row.id, external_id: row.external_id, name: row.name },
+        }),
+    };
+};

package/dist/store/sqlite/document-transfer/plan.js

@@ -1,8 +1,11 @@
 import { CliError } from "@wirecat/cli-base";
+import { folderProviderSql } from "../../../domain/providers.js";
 import { digest } from "../../document-transfer/digest.js";
 import { ownerPerson } from "../actors.js";
+import { tagMemberIds } from "../tag-resolution.js";
 import { canonicalTagNamed } from "../tags.js";
 import { stateOfThing, thingOf } from "../things.js";
+import { collectionAccounts, collectionNameOf, movedFromOf } from "./collection.js";
 import { planPeople } from "./people.js";
 export const planTransfer = (database, snapshot, sourceKey, bindings) => {
     const mappings = new Map();
@@ -10,21 +13,20 @@ export const planTransfer = (database, snapshot, sourceKey, bindings) => {
     const snapshotHash = digest(snapshot);
     const bindingsHash = digest(Object.entries(bindings).sort(([a], [b]) => a.localeCompare(b)));
     const collection = String(snapshot.collection.external_id);
-    const targets = database
-        .prepare("SELECT * FROM accounts WHERE provider='folder' AND name=? ORDER BY id LIMIT 2")
-        .all(String(snapshot.collection.name));
+    const targets = collectionAccounts(database, collectionNameOf(snapshot.collection));
     if (targets.length > 1)
         conflicts.add("the destination has duplicate document collection identities");
     const target = targets[0];
-    if (!target && database.prepare("SELECT id FROM accounts WHERE provider='folder' AND external_id=?").get(collection))
+    if (!target &&
+        database.prepare(`SELECT id FROM accounts WHERE ${folderProviderSql()} AND external_id=?`).get(collection))
         conflicts.add("source collection identity is held by another destination collection");
     const hasReceipts = database
         .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='document_annotation_transfers'")
         .get();
     const receipt = hasReceipts &&
         database
-            .prepare("SELECT * FROM document_annotation_transfers WHERE source_key=? AND collection=?")
-            .get(sourceKey, collection);
+            .prepare("SELECT * FROM document_annotation_transfers WHERE source_key=? AND collection IN (?,?,?) LIMIT 1")
+            .get(sourceKey, collection, String(movedFromOf(snapshot.collection)?.external_id ?? collection), String(movedFromOf(target)?.external_id ?? collection));
     if (receipt && (receipt.snapshot_hash !== snapshotHash || receipt.bindings_hash !== bindingsHash))
         conflicts.add("the source or binding decisions changed after a completed transfer; keep the original store selected");
     if (target && target.scope !== snapshot.collection.scope)
@@ -82,9 +84,10 @@ export const planTransfer = (database, snapshot, sourceKey, bindings) => {
                 continue;
         }
         else if (external.collection && external.external_id) {
+            const holders = JSON.stringify(collectionAccounts(database, external.collection).map(({ id }) => Number(id)));
             const row = database
-                .prepare("SELECT d.id FROM documents d JOIN accounts a ON a.id=d.account_id WHERE a.provider='folder' AND a.name=? AND d.external_id=? AND d.deleted_at IS NULL")
-                .get(external.collection, external.external_id);
+                .prepare("SELECT id FROM documents WHERE account_id IN (SELECT value FROM json_each(?)) AND external_id=? AND deleted_at IS NULL ORDER BY id LIMIT 1")
+                .get(holders, external.external_id);
             if (row)
                 found = { type: "document", id: Number(row.id) };
         }
@@ -106,7 +109,11 @@ export const planTransfer = (database, snapshot, sourceKey, bindings) => {
     if (target && target.organization_id !== organization)
         conflicts.add("the destination collection has a different organization binding");
     for (const tagging of snapshot.taggings) {
+        if (Number(tagging.tag_group_size ?? 1) > 1)
+            conflicts.add(`source tag ${String(tagging.tag_id)} belongs to a consolidated group; annotation transfer cannot preserve that group yet`);
         const tag = canonicalTagNamed(database, String(tagging.tag_name));
+        if (tag && tagMemberIds(database, tag.id).length > 1)
+            conflicts.add(`destination tag ${String(tag.id)} belongs to a consolidated group; annotation transfer cannot preserve independent contributions yet`);
         if (tag && tag.name !== tagging.tag_name)
             conflicts.add(`destination vocabulary resolves source tag ${String(tagging.tag_id)} to another canonical label`);
         if (tag && tag.kind !== tagging.tag_kind)

package/dist/store/sqlite/document-transfer/snapshot.js

@@ -1,7 +1,9 @@
 import { CliError } from "@wirecat/cli-base";
+import { filesAccountSql } from "../../../domain/providers.js";
 import { digest } from "../../document-transfer/digest.js";
 import { referenceOfThing, storedThing } from "../things.js";
 import { read } from "../transaction.js";
+import { collectionAccounts, collectionNameOf, currentCollection } from "./collection.js";
 export const TRANSFER_TABLES = { document: "documents", note: "notes", memory: "memories", fact: "facts" };
 const MAX_ENTITIES = 1000;
 const MAX_AUXILIARY = 10000;
@@ -14,9 +16,7 @@ const valuesOf = (row) => Object.fromEntries(Object.entries(row).map(([key, valu
     return [key, value];
 }));
 export const transferSnapshot = (database, collection) => read(database, () => {
-    const accounts = database
-        .prepare("SELECT * FROM accounts WHERE provider='folder' AND name=? ORDER BY id LIMIT 2")
-        .all(collection);
+    const accounts = collectionAccounts(database, collection);
     if (accounts.length > 1)
         throw new CliError("configuration_error", "the source has duplicate document collection identities; select a repaired copy before transferring");
     const account = accounts[0];
@@ -35,6 +35,11 @@ export const transferSnapshot = (database, collection) => read(database, () => {
     const entities = new Map();
     const links = new Map();
     const taggings = new Map();
+    const canonicalTags = Boolean(database.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='canonical_tags'").get());
+    const tagTable = canonicalTags ? "canonical_tags" : "tags";
+    const resolution = canonicalTags
+        ? "r.canonical_id AS tag_canonical_id,(SELECT count(*) FROM resolved_tags members WHERE members.canonical_id=r.canonical_id) AS tag_group_size"
+        : "t.id AS tag_canonical_id,1 AS tag_group_size";
     const dependencies = new Map();
     const depend = (type, id) => {
         if (type != null && id != null)
@@ -84,7 +89,7 @@ export const transferSnapshot = (database, collection) => read(database, () => {
             }
         }
         for (const row of database
-            .prepare("SELECT g.*,t.name AS tag_name,t.kind AS tag_kind FROM taggings g JOIN tags t ON t.id=g.tag_id WHERE g.taggable_type=? AND g.taggable_id=? ORDER BY g.id LIMIT 10001")
+            .prepare(`SELECT g.*,t.name AS tag_name,t.kind AS tag_kind,${resolution} FROM taggings g JOIN ${tagTable} t ON t.id=g.tag_id ${canonicalTags ? "JOIN resolved_tags r ON r.id=t.id" : ""} WHERE g.taggable_type=? AND g.taggable_id=? ORDER BY g.id LIMIT 10001`)
             .all(kind, Number(values.id))) {
             if (taggings.size >= MAX_AUXILIARY)
                 throw new CliError("validation_error", "annotation transfer exceeds 10000 tag assignments");
@@ -160,10 +165,10 @@ export const transferSnapshot = (database, collection) => read(database, () => {
         }
         if (thing.type === "document") {
             const doc = database
-                .prepare("SELECT a.name AS collection,d.external_id,d.body,d.content_hash,d.deleted_at FROM documents d JOIN accounts a ON a.id=d.account_id WHERE d.id=? AND a.provider='folder'")
+                .prepare(`SELECT a.provider,a.external_id AS account,a.name,d.external_id,d.body,d.content_hash,d.deleted_at FROM documents d JOIN accounts a ON a.id=d.account_id WHERE d.id=? AND ${filesAccountSql("a.provider")}`)
                 .get(thing.id);
             if (doc) {
-                item.collection = String(doc.collection);
+                item.collection = collectionNameOf({ provider: doc.provider, external_id: doc.account, name: doc.name });
                 item.external_id = String(doc.external_id);
                 const content = bounded({ body: doc.body, content_hash: doc.content_hash, deleted_at: doc.deleted_at });
                 item.document_fingerprint = digest(content);
@@ -172,7 +177,7 @@ export const transferSnapshot = (database, collection) => read(database, () => {
         external.push(item);
     }
     return {
-        collection: bounded(account),
+        collection: bounded(currentCollection(account)),
         entities: [...entities.values()].sort((a, b) => a.key.localeCompare(b.key)),
         links: [...links.values()].sort((a, b) => Number(a.id) - Number(b.id)),
         taggings: [...taggings.values()].sort((a, b) => Number(a.id) - Number(b.id)),

package/dist/store/sqlite/entity-types.d.ts

@@ -7,13 +7,17 @@ export declare const ENTITY_TABLES: {
     readonly account: "accounts";
     readonly attachment: "attachments";
     readonly bot: "bots";
+    readonly calendar_entry: "calendar_entries";
     readonly chat: "chats";
     readonly conversation: "conversations";
     readonly document: "documents";
     readonly document_picture: "documents";
     readonly email: "emails";
     readonly email_thread: "email_threads";
+    readonly event: "events";
+    readonly event_series: "event_series";
     readonly fact: "facts";
+    readonly file: "files";
     readonly identity: "identities";
     readonly image: "attachments";
     readonly meeting: "meetings";
@@ -26,7 +30,7 @@ export declare const ENTITY_TABLES: {
     readonly person: "persons";
     readonly place: "places";
     readonly project: "projects";
-    readonly tag: "tags";
+    readonly tag: "canonical_tags";
     readonly task: "tasks";
 };
 export type EntityType = keyof typeof ENTITY_TABLES;

package/dist/store/sqlite/entity-types.js

@@ -6,13 +6,17 @@ export const ENTITY_TABLES = {
     account: "accounts",
     attachment: "attachments",
     bot: "bots",
+    calendar_entry: "calendar_entries",
     chat: "chats",
     conversation: "conversations",
     document: "documents",
     document_picture: "documents",
     email: "emails",
     email_thread: "email_threads",
+    event: "events",
+    event_series: "event_series",
     fact: "facts",
+    file: "files",
     identity: "identities",
     image: "attachments",
     meeting: "meetings",
@@ -25,7 +29,7 @@ export const ENTITY_TABLES = {
     person: "persons",
     place: "places",
     project: "projects",
-    tag: "tags",
+    tag: "canonical_tags",
     task: "tasks",
 };
 export const isEntityType = (type) => Object.hasOwn(ENTITY_TABLES, type);

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

@@ -1,5 +1,5 @@
 import type { QueryAst } from "@wirecat/cli-base/query";
-import type { Event, EventCandidateFilter, EventSeries, NewRecord } from "../../meetings/index.js";
+import { type Event, type EventCandidateFilter, type EventSeries, type NewRecord } from "../../meetings/index.js";
 import type { CacheDatabase } from "../driver.js";
 /** JSON columns keep a missing value as SQL NULL, never the text `null`, so a read gives back what was saved. */
 export declare const toJson: (value: unknown) => string | null;
@@ -13,8 +13,14 @@ export declare const page: (filter: {
     limit?: number;
     offset?: number;
 }) => [number, number];
+export declare const eventOf: (row: Record<string, unknown>) => Event;
 export declare const events: (database: CacheDatabase, query?: QueryAst) => Event[];
-/** An event without an end occupies its start instant. */
+/**
+ * The events a meeting may belong to: overlapping in time, with exclusive ends so back-to-back meetings do not both
+ * match, and sharing its series or its room (`join_key`, never the link with its passcode). The room is matched on
+ * other meetings and on calendar entries, so an event with no meeting yet is found. An event without an end, and a
+ * meeting with none, occupy their start instant.
+ */
 export declare const eventCandidates: (database: CacheDatabase, filter: EventCandidateFilter) => Event[];
 export declare const createEvent: (database: CacheDatabase, input: NewRecord<Event>, now: number) => Event;
 export declare const createEventSeries: (database: CacheDatabase, input: NewRecord<EventSeries>, now: number) => EventSeries;

package/dist/store/sqlite/events.js

@@ -1,4 +1,6 @@
+import { joinKeyOf, } from "../../meetings/index.js";
 import { queryFilter } from "./query-filter.js";
+import { write } from "./transaction.js";
 /** JSON columns keep a missing value as SQL NULL, never the text `null`, so a read gives back what was saved. */
 export const toJson = (value) => value === null || value === undefined ? null : JSON.stringify(value);
 export const fromJson = (value) => (value === null || value === undefined ? null : JSON.parse(String(value)));
@@ -14,7 +16,7 @@ export const page = (filter) => {
         throw new Error("Invalid offset");
     return [filter.limit ?? -1, filter.offset ?? 0];
 };
-const eventOf = (row) => ({
+export const eventOf = (row) => ({
     id: Number(row.id),
     eventSeriesId: int(row.event_series_id),
     title: str(row.title),
@@ -25,6 +27,9 @@ const eventOf = (row) => ({
     timezone: str(row.timezone),
     origin: String(row.origin),
     deletedAt: int(row.deleted_at),
+    status: str(row.status),
+    allDay: bool(row.all_day),
+    sourceDeletedAt: int(row.source_deleted_at),
     createdAt: Number(row.created_at),
     updatedAt: Number(row.updated_at),
 });
@@ -52,17 +57,28 @@ export const events = (database, query) => {
         .all(...(where?.params ?? []))
         .map(eventOf);
 };
-/** An event without an end occupies its start instant. */
-export const eventCandidates = (database, filter) => database
-    .prepare(`SELECT e.* FROM events e
+/**
+ * The events a meeting may belong to: overlapping in time, with exclusive ends so back-to-back meetings do not both
+ * match, and sharing its series or its room (`join_key`, never the link with its passcode). The room is matched on
+ * other meetings and on calendar entries, so an event with no meeting yet is found. An event without an end, and a
+ * meeting with none, occupy their start instant.
+ */
+export const eventCandidates = (database, filter) => {
+    const key = joinKeyOf(filter.joinUrl) ?? "";
+    const end = Math.max(filter.endsAt, filter.startsAt + 1);
+    return database
+        .prepare(`SELECT e.* FROM events e
         WHERE e.deleted_at IS NULL AND e.starts_at IS NOT NULL
-          AND e.starts_at <= ? AND coalesce(e.ends_at, e.starts_at) >= ?
+          AND e.starts_at < ? AND coalesce(e.ends_at, e.starts_at + 1) > ?
           AND (e.event_series_id IN (SELECT event_series_id FROM meeting_series WHERE id = ?)
-            OR (? IS NOT NULL AND EXISTS (SELECT 1 FROM meetings m
-              WHERE m.event_id = e.id AND m.deleted_at IS NULL AND m.join_url = ?)))
+            OR (? <> '' AND (EXISTS (SELECT 1 FROM meetings m
+                WHERE m.event_id = e.id AND m.deleted_at IS NULL AND m.join_key = ?)
+              OR EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id AND ce.deleted_at IS NULL
+                AND ce.status <> 'cancelled' AND ce.join_key = ?))))
         ORDER BY e.id`)
-    .all(filter.endsAt, filter.startsAt, filter.meetingSeriesId, filter.joinUrl, filter.joinUrl)
-    .map(eventOf);
+        .all(end, filter.startsAt, filter.meetingSeriesId, key, key, key)
+        .map(eventOf);
+};
 export const createEvent = (database, input, now) => {
     if (input.eventSeriesId !== null && !exists(database, "event_series", input.eventSeriesId))
         throw new Error("Event series not found");
@@ -88,7 +104,15 @@ export const linkMeeting = (database, id, eventId, now, mode = "auto") => {
         throw new Error("Meeting not found");
     if (!exists(database, "events", eventId))
         throw new Error("Event not found");
-    database
-        .prepare(`UPDATE meetings SET event_id = ?, updated_at = ? WHERE id = ?${mode === "owner" ? "" : " AND event_id IS NULL"}`)
-        .run(eventId, now, id);
+    write(database, () => {
+        const from = database.prepare("SELECT event_id FROM meetings WHERE id = ?").get(id)?.event_id;
+        const changed = database
+            .prepare(`UPDATE meetings SET event_id = ?, updated_at = ? WHERE id = ?${mode === "owner" ? "" : " AND event_id IS NULL"}`)
+            .run(eventId, now, id).changes;
+        if (changed && int(from) !== eventId)
+            database
+                .prepare("INSERT INTO entity_link_events (linkable_type, linkable_id, entity_type, from_entity_id, to_entity_id, method, " +
+                "confidence, author, created_at) VALUES ('meeting', ?, 'event', ?, ?, ?, NULL, ?, ?)")
+                .run(id, int(from), eventId, mode === "owner" ? "owner" : "rules", mode === "owner" ? "owner" : "rules", now);
+    });
 };

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

@@ -0,0 +1,93 @@
+import type { CacheDatabase } from "../driver.js";
+type Row = Record<string, unknown>;
+/** A local file of a document, where it is and its own facts. */
+export interface LocalPlace {
+    accountId: number;
+    path: string;
+    contentHash: string | null;
+    frontMatter: unknown;
+}
+interface Placed {
+    id: number;
+    path: string;
+}
+/** A file's document is the one its writer saved it as (`import`); a change of it is logged as every link is. */
+export declare const logFileLink: (database: CacheDatabase, now: number, fileId: number, from: unknown, to: number | null, method?: string, author?: string) => {
+    changes: number;
+};
+/**
+ * Writes the `files` row of one document from the document as it is now: the document's source record. A Drive
+ * document (catalog metadata or Drive front matter) is keyed by its Drive file id and placed under its first parent;
+ * a local one by its path, under folder rows made from that path. `seen` marks a sync or import that returned it.
+ * `place` names a local file of the document other than the one its own columns name: a copy in another folder.
+ */
+export declare const syncFile: (database: CacheDatabase, now: number, documentId: number, { seen, depth, place, method, }?: {
+    seen?: boolean;
+    depth?: number;
+    place?: LocalPlace;
+    method?: string;
+}) => Placed | null;
+export declare const FILES_BACKFILL = "files_backfill_after";
+/**
+ * Writes the `files` row of every document stored before version 32, from the document after the cursor the
+ * migration left, in short writes: another process waits for one batch at most, and a stop resumes where it was.
+ */
+export declare const fillFiles: (database: CacheDatabase, now: () => number, { batch }?: {
+    batch?: number | undefined;
+}) => number;
+/** A source record of a document: one item in one place (`files` row). Times are ISO 8601. */
+export interface StoredFile {
+    id: string;
+    accountId: string;
+    externalId: string;
+    kind: "file" | "folder" | "page";
+    name: string;
+    path: string;
+    parentId: string | null;
+    /** `document:<id>`, or `null` for a local folder. */
+    document: string | null;
+    mime: string | null;
+    size: number | null;
+    contentHash: string | null;
+    url: string | null;
+    externalCreatedAt: string | null;
+    externalUpdatedAt: string | null;
+    metadata: Record<string, unknown> | null;
+    seenAt: string | null;
+    deletedAt: string | null;
+}
+export interface FileListQuery {
+    /** Everything at and below this folder path, from the account root. */
+    under?: string;
+    /** Paths holding this text, in any case and accent. */
+    pathContains?: string;
+    kind?: StoredFile["kind"];
+    includeDeleted?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export interface FilesStore {
+    /** The files of one account, by path. The account is always named: there is no default place. */
+    list(accountId: string, query?: FileListQuery): Promise<{
+        items: StoredFile[];
+        hasMore: boolean;
+    }>;
+    byPath(accountId: string, path: string): Promise<StoredFile | undefined>;
+    /** Every place a document is kept, the one it shows first: the owner's pin, else the most recently changed. */
+    ofDocument(reference: string): Promise<StoredFile[]>;
+    /** The owner's choice of the file a document shows (`document:<id>`, a file id of that document). */
+    pin(document: string, fileId: string): Promise<void>;
+    /** The document shows its most recently changed file again. */
+    unpin(document: string): Promise<void>;
+}
+export declare const fileOf: (row: Row) => StoredFile;
+/**
+ * The file a document shows (requirements 3.3): live ones first, then the owner's pin, then the most recently changed.
+ * Read with the document's row joined as `d`.
+ */
+export declare const PREFERRED_FILE = "f.deleted_at IS NOT NULL, f.id IS NOT d.pinned_file_id, coalesce(f.external_updated_at, f.updated_at) DESC, f.id DESC";
+export declare const filesStoreOver: ({ database, now }: {
+    database: CacheDatabase;
+    now: () => number;
+}) => FilesStore;
+export {};