@wirecat/cli-core 0.550.0 → 0.552.0

package/dist/services/link-scorers/email-domain.js

@@ -0,0 +1,64 @@
+import { contactRef } from "./shared.js";
+const WEIGHT = 0.3;
+const CONTACTS = 500;
+const MOST_PAIRS = 200;
+const FREE = new Set([
+    "gmail.com",
+    "outlook.com",
+    "hotmail.com",
+    "yahoo.com",
+    "icloud.com",
+    "proton.me",
+    "protonmail.com",
+]);
+/**
+ * People whose mail addresses share a company domain, related to each other, weakly: a shared domain does not prove
+ * they work together. Needs no project; the rule `relationships scan` ran before scorers existed.
+ */
+export const emailDomain = {
+    id: "email-domain",
+    version: 1,
+    candidates: async ({ store, sources, owner, signal }) => {
+        const domains = new Map();
+        for (const key of sources) {
+            if (key.provider !== "email")
+                continue;
+            signal?.throwIfAborted();
+            const contacts = await store.people.contacts(key, { order: "name", limit: CONTACTS, offset: 0 });
+            for (const contact of contacts.items) {
+                const address = String(contact.id).toLowerCase();
+                const domain = address.split("@")[1];
+                if (!domain || FREE.has(domain))
+                    continue;
+                const person = await store.people.personOf({ provider: key.provider, id: contact.id });
+                if (!person || `person:${person.uid}` === owner)
+                    continue;
+                const people = domains.get(domain) ?? new Map();
+                if (!people.has(`person:${person.uid}`))
+                    people.set(`person:${person.uid}`, contactRef(key.provider, contact.id));
+                domains.set(domain, people);
+            }
+        }
+        const found = [];
+        for (const [domain, people] of domains) {
+            const sorted = [...people].sort(([a], [b]) => a.localeCompare(b));
+            for (let left = 0; left < sorted.length; left++)
+                for (let right = left + 1; right < sorted.length; right++) {
+                    if (found.length >= MOST_PAIRS)
+                        return found;
+                    const [from, identity] = sorted[left];
+                    const [to] = sorted[right];
+                    found.push({
+                        from,
+                        to,
+                        kind: "related-to",
+                        weight: WEIGHT,
+                        why: `addresses share the domain ${domain}; this does not prove they work together`,
+                        evidence: [],
+                        identity,
+                    });
+                }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/index.d.ts

@@ -0,0 +1,9 @@
+export { aliasHits } from "./alias-hits.js";
+export { chatSenders } from "./chat-senders.js";
+export { chatTitle } from "./chat-title.js";
+export { emailDomain } from "./email-domain.js";
+export { mailThread } from "./mail-thread.js";
+export { memberChats } from "./member-chats.js";
+export { memberDialog } from "./member-dialog.js";
+export { BUILT_IN_PURPOSES, combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput, scanProjectLinks, } from "./scan.js";
+export type { LinkCandidate, LinkScorer, ScannedProject, ScannedProposal, ScanResult, ScorerInput, Signal, } from "./types.js";

package/dist/services/link-scorers/index.js

@@ -0,0 +1,8 @@
+export { aliasHits } from "./alias-hits.js";
+export { chatSenders } from "./chat-senders.js";
+export { chatTitle } from "./chat-title.js";
+export { emailDomain } from "./email-domain.js";
+export { mailThread } from "./mail-thread.js";
+export { memberChats } from "./member-chats.js";
+export { memberDialog } from "./member-dialog.js";
+export { BUILT_IN_PURPOSES, combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./scan.js";

package/dist/services/link-scorers/mail-thread.d.ts

@@ -0,0 +1,3 @@
+import type { LinkScorer } from "./types.js";
+/** A mail thread a confirmed member writes in or is written to: strong when its subject names the project. */
+export declare const mailThread: LinkScorer;

package/dist/services/link-scorers/mail-thread.js

@@ -0,0 +1,74 @@
+import { formatReference } from "../../domain/references.js";
+import { identitiesIn, namesProject } from "./shared.js";
+const NAMED = 0.7;
+const MEMBER_ONLY = 0.3;
+const READ_LIMIT = 500;
+/** A mail thread a confirmed member writes in or is written to: strong when its subject names the project. */
+export const mailThread = {
+    id: "mail-thread",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, since, owner, signal }) => {
+        if (!project)
+            return [];
+        const names = namesProject(project);
+        const people = confirmed.people.filter((person) => person !== owner);
+        const found = [];
+        for (const key of sources) {
+            if (key.provider !== "email")
+                continue;
+            const account = await store.accounts.storedAccount(key).catch(() => undefined);
+            if (!account)
+                continue;
+            const threads = new Map();
+            for (const { person, id } of await identitiesIn(store, people, "email")) {
+                signal?.throwIfAborted();
+                const emails = await store.mail.emails({
+                    accountId: account.id,
+                    participant: id,
+                    since: Date.parse(since),
+                    limit: READ_LIMIT,
+                });
+                for (const email of emails) {
+                    const held = threads.get(email.emailThreadId) ?? {
+                        members: new Set(),
+                        subject: email.subject,
+                        email: email.externalId,
+                    };
+                    held.members.add(person);
+                    threads.set(email.emailThreadId, held);
+                }
+            }
+            for (const [id, { members, subject, email }] of threads) {
+                const thread = (await store.mail.thread(id))?.thread;
+                if (!thread)
+                    continue;
+                const named = names(thread.subject ?? subject) !== undefined;
+                const chat = formatReference({
+                    type: "chat",
+                    provider: "email",
+                    account: String(key.account),
+                    chat: thread.externalId,
+                });
+                const who = [...members].sort();
+                found.push({
+                    from: chat,
+                    to: project.ref,
+                    kind: "member-of",
+                    weight: named ? NAMED : MEMBER_ONLY,
+                    why: `a thread with ${who.length > 1 ? `${who.length} members` : `a member (${who[0]})`}${named ? "; its subject names the project" : ""}`,
+                    evidence: [
+                        formatReference({
+                            type: "message",
+                            provider: "email",
+                            account: String(key.account),
+                            chat: thread.externalId,
+                            message: email,
+                        }),
+                        ...who,
+                    ].slice(0, 5),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/member-chats.d.ts

@@ -0,0 +1,3 @@
+import type { LinkScorer } from "./types.js";
+/** A group or channel where two or more of the project's confirmed person members are members. */
+export declare const memberChats: LinkScorer;

package/dist/services/link-scorers/member-chats.js

@@ -0,0 +1,40 @@
+import { chatRef, identitiesIn } from "./shared.js";
+const WEIGHT = 0.5;
+/** A group or channel where two or more of the project's confirmed person members are members. */
+export const memberChats = {
+    id: "member-chats",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, owner, signal }) => {
+        if (!project)
+            return [];
+        const people = confirmed.people.filter((person) => person !== owner);
+        const found = [];
+        for (const key of sources) {
+            const members = new Map();
+            for (const { person, id } of await identitiesIn(store, people, key.provider)) {
+                signal?.throwIfAborted();
+                for (const chat of await store.chats.chatsWith(key, id)) {
+                    if (chat.kind !== "group" && chat.kind !== "channel")
+                        continue;
+                    const held = members.get(String(chat.id)) ?? new Set();
+                    held.add(person);
+                    members.set(String(chat.id), held);
+                }
+            }
+            for (const [chat, held] of members) {
+                if (held.size < 2)
+                    continue;
+                const named = [...held].sort();
+                found.push({
+                    from: chatRef(key, chat),
+                    to: project.ref,
+                    kind: "member-of",
+                    weight: WEIGHT,
+                    why: `a group with ${held.size} confirmed members (${named.slice(0, 3).join(", ")}${held.size > 3 ? ", …" : ""})`,
+                    evidence: named.slice(0, 5),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/member-dialog.d.ts

@@ -0,0 +1,3 @@
+import type { LinkScorer } from "./types.js";
+/** A dialog with a confirmed person member, divided by how many projects that person is a member of. */
+export declare const memberDialog: LinkScorer;

package/dist/services/link-scorers/member-dialog.js

@@ -0,0 +1,34 @@
+import { chatRef, identitiesIn, projectsOf } from "./shared.js";
+const WEIGHT = 0.6;
+/** A dialog with a confirmed person member, divided by how many projects that person is a member of. */
+export const memberDialog = {
+    id: "member-dialog",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, owner, signal }) => {
+        if (!project)
+            return [];
+        const people = confirmed.people.filter((person) => person !== owner);
+        const projects = new Map();
+        const found = [];
+        for (const key of sources)
+            for (const { person, id } of await identitiesIn(store, people, key.provider)) {
+                signal?.throwIfAborted();
+                for (const chat of await store.chats.chatsWith(key, id)) {
+                    if (chat.kind !== "dialog")
+                        continue;
+                    if (!projects.has(person))
+                        projects.set(person, Math.max(1, await projectsOf(store, person)));
+                    const shared = projects.get(person) ?? 1;
+                    found.push({
+                        from: chatRef(key, chat.id),
+                        to: project.ref,
+                        kind: "member-of",
+                        weight: WEIGHT / shared,
+                        why: `a dialog with a member (${person})${shared > 1 ? `, who is in ${shared} projects` : ""}`,
+                        evidence: [person],
+                    });
+                }
+            }
+        return found;
+    },
+};

package/dist/services/link-scorers/scan.d.ts

@@ -0,0 +1,41 @@
+import type { MessageStore } from "../../store/store.js";
+import type { AccountKey } from "../../store/types.js";
+import type { LinkScorer, ScanResult } from "./types.js";
+/** A new scorer is one file and one line here. */
+export declare const SCORERS: readonly LinkScorer[];
+/** What a scan with no project runs: person ↔ person rules. */
+export declare const PERSON_SCORERS: readonly LinkScorer[];
+/** The rule bot every scan proposal is written by: only the owner decides its proposals. */
+export declare const SCAN_BOT: {
+    readonly bot: "memo-scan";
+    readonly kind: "rule";
+};
+export declare const BUILT_IN_PURPOSES: readonly ["work", "sales", "support", "other"];
+export declare const DEFAULT_THRESHOLD = 0.5;
+/** A person ↔ person scan keeps the old rule's reach: one weak signal is enough to ask the owner. */
+export declare const PERSON_THRESHOLD = 0.3;
+export declare const DEFAULT_LIMIT = 20;
+export interface ScanInput {
+    /** A project's key, name, alias or `project:<id>`; `null` runs the person ↔ person rules. */
+    project: string | null;
+    sources: AccountKey[];
+    since: string;
+    /** `false` reads only: nothing is written, and each proposal says `dry-run`. */
+    write: boolean;
+    scorers?: readonly LinkScorer[];
+    threshold?: number;
+    /** Most new proposals in one run, 1–50. */
+    limit?: number;
+    /** The host's configured purposes; built-in when left out. */
+    purposes?: readonly string[];
+    signal?: AbortSignal;
+}
+/** 1 − Π(1 − wᵢ), over each scorer's strongest signal for the pair. */
+export declare const combinedScore: (weights: readonly number[]) => number;
+/**
+ * Runs the scorers for one project over the sources named, combines their signals per pair, and proposes what scores
+ * `threshold` or more, highest first, at most `limit` new ones. A pair a link joins, or that was rejected once, is
+ * never proposed; a pending one is updated in place. People are matched by identity only. With `write: false`
+ * nothing is written.
+ */
+export declare const scanProjectLinks: (store: MessageStore, input: ScanInput) => Promise<ScanResult>;

package/dist/services/link-scorers/scan.js

@@ -0,0 +1,244 @@
+import { CliError } from "@wirecat/cli-base";
+import { parseReference } from "../../domain/references.js";
+import { canonicalProjectRef } from "../stored-project-gathering.js";
+import { aliasHits } from "./alias-hits.js";
+import { chatSenders } from "./chat-senders.js";
+import { chatTitle } from "./chat-title.js";
+import { emailDomain } from "./email-domain.js";
+import { mailThread } from "./mail-thread.js";
+import { memberChats } from "./member-chats.js";
+import { memberDialog } from "./member-dialog.js";
+import { sameAccount } from "./shared.js";
+/** A new scorer is one file and one line here. */
+export const SCORERS = [chatTitle, aliasHits, memberChats, memberDialog, chatSenders, mailThread];
+/** What a scan with no project runs: person ↔ person rules. */
+export const PERSON_SCORERS = [emailDomain];
+/** The rule bot every scan proposal is written by: only the owner decides its proposals. */
+export const SCAN_BOT = { bot: "memo-scan", kind: "rule" };
+export const BUILT_IN_PURPOSES = ["work", "sales", "support", "other"];
+export const DEFAULT_THRESHOLD = 0.5;
+/** A person ↔ person scan keeps the old rule's reach: one weak signal is enough to ask the owner. */
+export const PERSON_THRESHOLD = 0.3;
+export const DEFAULT_LIMIT = 20;
+const projectOf = async (store, reference) => {
+    const ref = await canonicalProjectRef(store, reference);
+    const entry = (await store.knowledge.vocabulary({ kind: "project" })).entries.find((one) => one.id === ref.slice(8));
+    if (!entry)
+        throw new CliError("not_found", `no project ${reference}`);
+    return { ref, name: entry.name, key: entry.key, aliases: entry.aliases.map((alias) => alias.name) };
+};
+const confirmedOf = async (store, project) => {
+    if (!project)
+        return { chats: [], people: [] };
+    const members = (await store.knowledge.relations(null, project.ref)).filter((one) => one.confirmed && one.kind === "member-of" && one.to === project.ref);
+    return {
+        chats: [...new Set(members.map((one) => one.from).filter((ref) => ref.startsWith("chat:")))].sort(),
+        people: [...new Set(members.map((one) => one.from).filter((ref) => ref.startsWith("person:")))].sort(),
+    };
+};
+const checkedSources = async (store, sources) => {
+    const stored = await store.accounts.accounts();
+    const choices = stored.map((one) => `${one.provider}:${one.account}`);
+    if (!Array.isArray(sources) || sources.length === 0)
+        throw new CliError("validation_error", "a scan names the accounts it reads; none is picked for you", {
+            param: "source",
+            choices,
+        });
+    for (const source of sources)
+        if (!stored.some((one) => one.provider === source.provider && String(one.account) === String(source.account)))
+            throw new CliError("not_found", `the store holds no account ${source.provider}:${source.account}`, {
+                param: "source",
+                choices,
+            });
+    return sources;
+};
+const pairKey = ({ from, to, kind }) => `${from}\u0000${to}\u0000${kind}`;
+/** 1 − Π(1 − wᵢ), over each scorer's strongest signal for the pair. */
+export const combinedScore = (weights) => Math.round((1 - weights.reduce((left, weight) => left * (1 - weight), 1)) * 1000) / 1000;
+/**
+ * Runs the scorers for one project over the sources named, combines their signals per pair, and proposes what scores
+ * `threshold` or more, highest first, at most `limit` new ones. A pair a link joins, or that was rejected once, is
+ * never proposed; a pending one is updated in place. People are matched by identity only. With `write: false`
+ * nothing is written.
+ */
+export const scanProjectLinks = async (store, input) => {
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50)
+        throw new CliError("validation_error", "a scan proposes 1–50 links a run", { param: "limit" });
+    const threshold = input.threshold ?? (input.project === null ? PERSON_THRESHOLD : DEFAULT_THRESHOLD);
+    if (typeof threshold !== "number" || !(threshold > 0 && threshold <= 1))
+        throw new CliError("validation_error", "a scan's threshold is more than 0 and at most 1", { param: "threshold" });
+    const since = Date.parse(input.since);
+    if (Number.isNaN(since))
+        throw new CliError("validation_error", "a scan's window starts at an ISO 8601 time", { param: "since" });
+    const sources = await checkedSources(store, input.sources);
+    const project = input.project === null ? null : await projectOf(store, input.project);
+    const owner = await store.people.owner();
+    const scorerInput = {
+        store,
+        project,
+        confirmed: await confirmedOf(store, project),
+        sources,
+        since: new Date(since).toISOString(),
+        purposes: input.purposes ?? BUILT_IN_PURPOSES,
+        owner: owner ? `person:${owner.uid}` : null,
+        ...(input.signal ? { signal: input.signal } : {}),
+    };
+    const scorers = input.scorers ?? (project ? SCORERS : PERSON_SCORERS);
+    const skipped = {
+        confirmed: 0,
+        rejected: 0,
+        belowThreshold: 0,
+        overLimit: 0,
+        nameOnly: 0,
+        unresolved: 0,
+    };
+    const pairs = new Map();
+    const nameOnly = new Set();
+    for (const scorer of scorers) {
+        input.signal?.throwIfAborted();
+        for (const candidate of await scorer.candidates(scorerInput)) {
+            const key = pairKey(candidate);
+            const verdict = await admissible(store, scorerInput, candidate);
+            if (verdict === "owner")
+                continue;
+            if (verdict === "name-only") {
+                if (!nameOnly.has(key))
+                    skipped.nameOnly++;
+                nameOnly.add(key);
+                continue;
+            }
+            if (verdict !== "ok") {
+                skipped.unresolved++;
+                continue;
+            }
+            const weight = Math.min(1, Math.max(0, candidate.weight));
+            const held = pairs.get(key) ?? { candidate, signals: new Map() };
+            const scorerId = `${scorer.id}@${scorer.version}`;
+            const before = held.signals.get(scorerId);
+            if (!before || before.weight < weight)
+                held.signals.set(scorerId, {
+                    scorer: scorerId,
+                    weight,
+                    why: candidate.why.slice(0, 500),
+                    ...(candidate.purpose && scorerInput.purposes.includes(candidate.purpose)
+                        ? { purpose: candidate.purpose }
+                        : {}),
+                });
+            held.candidate = {
+                ...held.candidate,
+                evidence: [...new Set([...held.candidate.evidence, ...candidate.evidence])],
+            };
+            pairs.set(key, held);
+        }
+    }
+    const scored = [...pairs.values()]
+        .map(({ candidate, signals }) => {
+        const list = [...signals.values()].sort((a, b) => b.weight - a.weight || a.scorer.localeCompare(b.scorer));
+        const purpose = list.find((one) => one.purpose)?.purpose;
+        return {
+            candidate,
+            purpose,
+            signals: list.map(({ scorer, weight, why }) => ({ scorer, weight, why })),
+            score: combinedScore(list.map((one) => one.weight)),
+        };
+    })
+        .sort((a, b) => b.score - a.score || a.candidate.from.localeCompare(b.candidate.from));
+    const proposals = [];
+    let fresh = 0;
+    for (const { candidate, purpose, signals, score } of scored) {
+        const state = await store.knowledge.relationState(null, candidate);
+        if (!state) {
+            skipped.unresolved++;
+            continue;
+        }
+        if (state.linked) {
+            skipped.confirmed++;
+            continue;
+        }
+        if (state.rejected || (await rejectedReversed(store, candidate))) {
+            skipped.rejected++;
+            continue;
+        }
+        if (score < threshold) {
+            skipped.belowThreshold++;
+            continue;
+        }
+        if (!state.pending && fresh >= limit) {
+            skipped.overLimit++;
+            continue;
+        }
+        if (!state.pending)
+            fresh++;
+        const { identity: _identity, purpose: _purpose, weight: _weight, why: _why, ...pair } = candidate;
+        const evidence = candidate.evidence.slice(0, 5);
+        const proposal = {
+            ...pair,
+            weight: score,
+            why: signals.map((one) => one.why).join("; "),
+            evidence,
+            ...(purpose ? { purpose } : {}),
+            score,
+            signals,
+        };
+        if (!input.write) {
+            proposals.push({ ...proposal, id: state.pending?.id ?? null, state: "dry-run" });
+            continue;
+        }
+        const written = await store.knowledge.proposeRelation(null, {
+            from: pair.from,
+            to: pair.to,
+            kind: pair.kind,
+            evidence,
+            reason: proposal.why.slice(0, 2000),
+            score,
+            signals,
+            ...(purpose ? { purpose } : {}),
+        }, SCAN_BOT);
+        proposals.push({
+            ...proposal,
+            id: written.id,
+            state: !state.pending
+                ? "new"
+                : JSON.stringify(written.payload) === JSON.stringify(state.pending.payload)
+                    ? "unchanged"
+                    : "updated",
+        });
+    }
+    return { project: project?.ref ?? null, proposals, skipped };
+};
+/** A person candidate stands only on an identity that is that person's; a chat only in a source the scan reads. */
+const admissible = async (store, input, candidate) => {
+    if (candidate.from === candidate.to || !Number.isFinite(candidate.weight))
+        return "unresolved";
+    if (input.project && candidate.to !== input.project.ref && !candidate.to.startsWith("person:"))
+        return "unresolved";
+    if (candidate.from === input.owner || candidate.to === input.owner)
+        return "owner";
+    if (candidate.from.startsWith("person:")) {
+        const identity = candidate.identity === undefined ? undefined : referenceOf(candidate.identity);
+        if (identity?.type !== "contact")
+            return "name-only";
+        const person = await store.people.personOf({ provider: identity.provider, id: identity.id });
+        return person !== undefined && `person:${person.uid}` === candidate.from ? "ok" : "name-only";
+    }
+    if (candidate.from.startsWith("chat:")) {
+        const chat = referenceOf(candidate.from);
+        return chat?.type === "chat" && input.sources.some((source) => sameAccount(source, chat)) ? "ok" : "unresolved";
+    }
+    return "unresolved";
+};
+const referenceOf = (text) => {
+    try {
+        return parseReference(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** A person ↔ person relation reads both ways: rejecting B → A also rejects A → B. */
+const rejectedReversed = async (store, candidate) => candidate.kind === "related-to" &&
+    candidate.to.startsWith("person:") &&
+    ((await store.knowledge.relationState(null, { from: candidate.to, to: candidate.from, kind: candidate.kind }))
+        ?.rejected ??
+        false);

package/dist/services/link-scorers/shared.d.ts

@@ -0,0 +1,26 @@
+import type { Id } from "../../domain/models.js";
+import type { MessageStore } from "../../store/store.js";
+import type { AccountKey } from "../../store/types.js";
+import type { ScannedProject } from "./types.js";
+/** A whole-word test, the rule the evidence lanes and meeting candidates use: «Harbour» is not in «Harbourside». */
+export declare const wholeWords: (term: string) => RegExp;
+/** The project's name, key and aliases, each once. */
+export declare const projectTerms: (project: ScannedProject) => string[];
+/** The first of the project's terms a text names as whole words. */
+export declare const namesProject: (project: ScannedProject) => ((text: string | null | undefined) => string | undefined);
+export declare const chatRef: (key: AccountKey, chat: Id) => string;
+export declare const contactRef: (provider: string, id: Id) => string;
+export declare const sameAccount: (a: AccountKey, b: {
+    provider: string;
+    account: string;
+}) => boolean;
+/** The person an identity is, as `person:<uid>`; `undefined` when the store has no person for it. */
+export declare const personRefOf: (store: MessageStore, provider: string, id: Id) => Promise<string | undefined>;
+/** How many projects a person is a confirmed member of. */
+export declare const projectsOf: (store: MessageStore, person: string) => Promise<number>;
+/** Each confirmed member's identities in one messenger, by member. */
+export declare const identitiesIn: (store: MessageStore, people: readonly string[], provider: string) => Promise<{
+    person: string;
+    id: string;
+}[]>;
+export declare const aborted: (signal: AbortSignal | undefined) => void;

package/dist/services/link-scorers/shared.js

@@ -0,0 +1,48 @@
+import { formatReference } from "../../domain/references.js";
+import { normalizeVocabularyName } from "../../domain/vocabulary.js";
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const folded = (text) => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+/** A whole-word test, the rule the evidence lanes and meeting candidates use: «Harbour» is not in «Harbourside». */
+export const wholeWords = (term) => new RegExp(`(?<![\\p{L}\\p{N}\\p{M}_])${escaped(normalizeVocabularyName(term))}(?![\\p{L}\\p{N}\\p{M}_])`, "u");
+/** The project's name, key and aliases, each once. */
+export const projectTerms = (project) => {
+    const terms = new Map();
+    for (const term of [project.name, project.key, ...project.aliases])
+        if (term?.trim())
+            terms.set(normalizeVocabularyName(term), term);
+    return [...terms.values()];
+};
+/** The first of the project's terms a text names as whole words. */
+export const namesProject = (project) => {
+    const patterns = projectTerms(project).map((term) => ({ term, pattern: wholeWords(term) }));
+    return (text) => {
+        if (!text)
+            return undefined;
+        const value = folded(text);
+        return patterns.find(({ pattern }) => pattern.test(value))?.term;
+    };
+};
+export const chatRef = (key, chat) => formatReference({ type: "chat", provider: key.provider, account: String(key.account), chat: String(chat) });
+export const contactRef = (provider, id) => formatReference({ type: "contact", provider, id: String(id) });
+export const sameAccount = (a, b) => a.provider === b.provider && String(a.account) === b.account;
+/** The person an identity is, as `person:<uid>`; `undefined` when the store has no person for it. */
+export const personRefOf = async (store, provider, id) => {
+    const person = await store.people.personOf({ provider, id });
+    return person ? `person:${person.uid}` : undefined;
+};
+/** How many projects a person is a confirmed member of. */
+export const projectsOf = async (store, person) => new Set((await store.knowledge.relations(null, person))
+    .filter((one) => one.confirmed && one.kind === "member-of" && one.from === person && one.to.startsWith("project:"))
+    .map((one) => one.to)).size;
+/** Each confirmed member's identities in one messenger, by member. */
+export const identitiesIn = async (store, people, provider) => {
+    const found = [];
+    for (const person of people) {
+        const record = await store.people.personByUid(person.slice("person:".length));
+        for (const identity of record?.identities ?? [])
+            if (identity.provider === provider)
+                found.push({ person, id: String(identity.id) });
+    }
+    return found;
+};
+export const aborted = (signal) => signal?.throwIfAborted();