@wirecat/cli-core 0.396.0 → 0.398.0

package/dist/cli/messenger/search-command.js

@@ -34,9 +34,10 @@ const maxMeetingsOf = (value) => {
 };
 const allCommand = (messenger) => {
     const command = annotate(new Command("all"), { effects: REMOTE_READ, partial: true })
+        .summary("search stored messages, notes and selected meeting transcripts")
         .description((messenger.serverSearch
-        ? "search messenger messages and notes in the local store, and the messenger's server for messages " +
-            "(--backend; notes are local only)"
+        ? "search messenger messages and notes in the local store, and by default the messenger's server for " +
+            "messages too (notes are local only; --backend archive or --offline keeps it to the local store)"
         : "search messenger messages and notes in the local store") +
         ", and a meeting account's transcripts when --source names one — best match first; not mail (the separate memo CLI searches it: memo search mail), " +
         "tasks, people, memories or projects. Use it when you do not know where something was written; search messages " +
@@ -95,6 +96,7 @@ const allCommand = (messenger) => {
     });
 };
 const notesCommand = (messenger) => annotate(new Command("notes"), { effects: LOCAL_READ, partial: true, output: { entity: "note", view: "hit" } })
+    .summary("find stored notes by words and filters")
     .description("search the notes — written in memo, or imported from a notes folder — by words and, with the local " +
     "text model, by meaning; each hit says which found it and what it links to")
     .argument("<query...>", 'strict Lucene query: words, "phrases", AND/OR/NOT, tag:, source:internal (written in memo) or source:file ' +
@@ -150,7 +152,9 @@ const notesCommand = (messenger) => annotate(new Command("notes"), { effects: LO
  * hierarchy"). `topics` only where the CLI has forum topics.
  */
 export const searchCommand = (messenger, { topics = false } = {}) => {
-    const search = new Command("search").description("find things by text: one resource when you know it (messages, notes), or search all across messages and notes; for mail, the separate memo CLI: memo search mail");
+    const search = new Command("search")
+        .summary("search the local archive")
+        .description("find things by text: one resource when you know it (messages, notes), or search all across messages and notes; for mail, the separate memo CLI: memo search mail");
     search
         .addCommand(allCommand(messenger))
         .addCommand(messagesSearchCommand(messenger))

package/dist/cli/messenger/searches-command.js

@@ -24,8 +24,16 @@ const line = ({ id, name, command, params, runs, lastRunAt }) => [
 export const SEARCHES_QUERY = unfilteredQuery("saved_search", savedSearch);
 /** Saved searches and the history of `search messages` and `stats messages show`, in the local store only. */
 export const searchesCommand = (messenger) => {
-    const searches = new Command("searches").description("saved searches and the history of search messages and stats messages show, kept in the local store; --saved runs one");
-    annotate(searches.command("create"), { effects: LOCAL_WRITE, output: { entity: "saved_search" } })
+    const tool = `${messenger.app.command} personal`;
+    const searches = new Command("searches")
+        .summary("saved searches and their run history")
+        .description("saved searches and the history of search messages and stats messages show, kept in the local store; --saved runs one");
+    annotate(searches.command("create"), {
+        effects: LOCAL_WRITE,
+        output: { entity: "saved_search" },
+        examples: [`${tool} searches create project-drafts draft --chat "Project room"`],
+    })
+        .summary("save a search and its query")
         .description("save a search under a name without running it; search messages --saved <name> runs it")
         .argument("<name>", "up to 64 letters a–z, digits and hyphens, not only digits")
         .argument("[query...]", "the query, as for search messages; none matches every stored message")
@@ -64,7 +72,11 @@ export const searchesCommand = (messenger) => {
         const saved = await context.withServices((services) => services.searches.create(name, params, { replace: replace === true }));
         renderAnswer(this, context, itemOf(savedSearchItem(saved)), () => `${line(saved)}\n`);
     });
-    annotate(searches.command("show"), { effects: REMOTE_READ, output: { entity: "saved_search" } })
+    annotate(searches.command("show"), {
+        effects: REMOTE_READ,
+        output: { entity: "saved_search" },
+        examples: [`${tool} searches show project-drafts`],
+    })
         .description("one saved search or earlier run: its query, options and how often it ran")
         .argument("<name|id>", "a saved search's name, or the id of any row of searches history")
         .action(async function (reference) {
@@ -72,7 +84,7 @@ export const searchesCommand = (messenger) => {
         const found = await context.withServices((services) => services.searches.show(reference));
         renderAnswer(this, context, itemOf(savedSearchItem(found)), () => `${line(found)}\n`);
     });
-    withQuery(annotate(searches.command("list"), { effects: LOCAL_READ }), SEARCHES_QUERY)
+    withQuery(annotate(searches.command("list"), { effects: LOCAL_READ, examples: [`${tool} searches list`] }), SEARCHES_QUERY)
         .description("the saved searches, by name")
         .action(async function (words) {
         const context = messengerContext(this, messenger);
@@ -83,9 +95,10 @@ export const searchesCommand = (messenger) => {
         if (found.length === 0 && context.format === "pretty")
             context.renderer.note("no saved searches — `searches create <name> <query>` saves one");
     });
-    annotate(withPaging(annotate(searches.command("history"), { effects: LOCAL_READ })), {
+    annotate(withPaging(annotate(searches.command("history"), { effects: LOCAL_READ, examples: [`${tool} searches history --limit 10`] })), {
         output: { entity: "saved_search" },
     })
+        .summary("past searches and counts, without their results")
         .description("the searches and counts that ran, newest first — saved ones included; never their results")
         .action(async function () {
         const context = messengerContext(this, messenger);
@@ -98,7 +111,11 @@ export const searchesCommand = (messenger) => {
         if (found.items.length === 0 && context.format === "pretty")
             context.renderer.note("no searches ran yet");
     });
-    annotate(searches.command("delete"), { effects: LOCAL_WRITE, output: { entity: "saved_search" } })
+    annotate(searches.command("delete"), {
+        effects: LOCAL_WRITE,
+        output: { entity: "saved_search" },
+        examples: [`${tool} searches delete project-drafts`],
+    })
         .description("delete a saved search, or one run from the history")
         .argument("<name|id>", "a saved search's name, or the id of any row of searches history")
         .action(async function (reference) {
@@ -107,7 +124,7 @@ export const searchesCommand = (messenger) => {
         const deleted = await context.withServices((services) => services.searches.delete(reference));
         renderAnswer(this, context, itemOf(savedSearchItem(deleted)), () => `deleted ${deleted.name ?? `run ${deleted.id}`}\n`);
     });
-    annotate(searches.command("clear"), { effects: LOCAL_WRITE })
+    annotate(searches.command("clear"), { effects: LOCAL_WRITE, examples: [`${tool} searches clear`] })
         .description("empty the history; saved searches stay")
         .action(async function () {
         const context = messengerContext(this, messenger);

package/dist/cli/messenger/serve-command.js

@@ -30,7 +30,11 @@ export { lockPath, readLock, servingProfiles } from "../../background/lock.js";
  * taken over. Started by a person, a service unit or `server start` — never by itself (NEED-9).
  */
 export const serveCommand = (messenger) => {
-    const command = annotate(new Command("serve"), { effects: REMOTE_WRITE, lifetime: "persistent" }).description("keep the local store current until stopped — what a systemd or launchd unit runs");
+    const command = annotate(new Command("serve"), {
+        effects: REMOTE_WRITE,
+        lifetime: "persistent",
+        examples: [`${messenger.app.command} personal serve`],
+    }).description("keep the local store current until stopped — what a systemd or launchd unit runs");
     command.action(async function () {
         const relay = messenger.connection === "exclusive" && process.platform !== "win32" ? serveRelay(this, messenger) : undefined;
         const context = recordDiagnostics(messengerContext(this, relay?.messenger ?? messenger), messenger.app);

package/dist/cli/messenger/serve-relay.d.ts

@@ -51,6 +51,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         scheduledSends?: boolean;
         autoReplies?: boolean;
         lacks?: readonly (keyof MessengerAdapter)[];
+        never?: readonly (keyof MessengerAdapter)[];
         deleteForMe?: boolean;
         topics?: boolean;
         topicShow?: boolean;

package/dist/cli/messenger/server-command.js

@@ -60,7 +60,9 @@ const lockProcess = (app, marker, serveArgv) => (context, system, logPath) => ({
  */
 export const serverCommand = (messenger, options = {}) => {
     const { app } = messenger;
-    const command = annotate(new Command("server"), { mcp: false }).description(`\`${app.command} serve\` in the background: start, stop, restart, status, logs; install adds a systemd or launchd unit`);
+    const command = new Command("server")
+        .summary("manage this profile's background server")
+        .description(`\`${app.command} serve\` in the background: start, stop, restart, status, logs; install adds a systemd or launchd unit`);
     const marker = (profile) => `${app.envPrefix}_SERVER=${profile}`;
     const serveArgv = options.serveArgv ?? ["serve"];
     const prepare = (self) => {
@@ -181,15 +183,26 @@ export const serverCommand = (messenger, options = {}) => {
         return ["--idle", idle];
     };
     const withIdle = (sub) => options.idle ? sub.option("--idle <duration>", "stop after this long with nobody using it — 15m, 1h") : sub;
-    withIdle(destroysNothing(annotate(command.command("start"), { effects: LOCAL_WRITE, examples: [`${app.command} personal server start`] })).description("start serve in the background — through the unit if one is installed — and answer once it connects")).action(async function () {
+    withIdle(destroysNothing(annotate(command.command("start"), {
+        effects: LOCAL_WRITE,
+        mcp: false,
+        examples: [`${app.command} personal server start`],
+    }))
+        .summary("start this profile's background server")
+        .description("start serve in the background — through the unit if one is installed — and answer once it connects")).action(async function () {
         await start(prepare(this), idleArgs(this));
     });
-    destroysNothing(annotate(command.command("stop"), { effects: LOCAL_WRITE, examples: [`${app.command} personal server stop`] }))
+    destroysNothing(annotate(command.command("stop"), {
+        effects: LOCAL_WRITE,
+        mcp: false,
+        examples: [`${app.command} personal server stop`],
+    }))
         .description("stop this profile's serve — through the unit if it runs under one")
         .action(async function () {
         await stop(prepare(this));
     });
     withIdle(destroysNothing(annotate(command.command("restart"), {
+        mcp: false,
         effects: LOCAL_WRITE,
         examples: [`${app.command} personal server restart`],
     })).description("stop it and start it again")).action(async function () {
@@ -199,6 +212,7 @@ export const serverCommand = (messenger, options = {}) => {
         await start(prepared, args);
     });
     annotate(command.command("status"), { effects: LOCAL_READ, examples: [`${app.command} personal server status`] })
+        .summary("this profile's background-server status")
         .description("whether serve runs for this profile, since when, who started it, and the unit if there is one")
         .action(async function () {
         const prepared = prepare(this);

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -2,9 +2,9 @@ import { Command } from "commander";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
-    error?: undefined;
     path: string;
     exists: boolean;
+    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/cli/messenger/store-maintenance-command.js

@@ -93,6 +93,7 @@ const refuseWhileServing = (command, messenger) => {
     }
 };
 const repairCommand = (messenger) => annotate(new Command("repair"), { effects: LOCAL_WRITE, mcp: false })
+    .summary("repair table shapes while keeping the old tables")
     .description("bring every table to this build's shape, deleting nothing: a table of the wrong shape is kept as a copy beside a new one")
     .option("--dry-run", "say what it would do, and change nothing")
     .action(async function () {
@@ -151,7 +152,8 @@ const copiesCommand = () => new Command("copies").description("the tables `store
     const deleted = await reading(path, (database) => deleteCopy(database, name));
     result(this, { path, deleted });
 }));
-const infoCommand = () => annotate(new Command("info"), { effects: LOCAL_READ, mcp: false })
+const infoCommand = () => annotate(new Command("info"), { effects: LOCAL_READ })
+    .summary("the local archive's format, size and contents")
     .description("the store file: where it is, its size, its schema and how many rows it holds; changes nothing")
     .action(async function () {
     const path = storePath(environmentOf(this).env ?? process.env);
@@ -180,7 +182,8 @@ const infoCommand = () => annotate(new Command("info"), { effects: LOCAL_READ, m
  * fetched" (NEED-399 A). Times are the chat's newest message by the messenger's list against the
  * newest message held, not `sync_ranges`: those are in message ids, which a chat list does not give.
  */
-const checkCommand = (messenger) => annotate(new Command("check"), { effects: LOCAL_READ, mcp: false })
+const checkCommand = (messenger) => annotate(new Command("check"), { effects: LOCAL_READ })
+    .summary("check the local archive for problems")
     .description("whether the store is healthy — integrity, search indexes, disk, and which chats are behind")
     .action(async function () {
     const { renderer } = outputFor(this);
@@ -360,6 +363,7 @@ const chatsBehind = (database) => database
     refreshed: isoOf(row.refreshed),
 }));
 const migrateCommand = (messenger) => annotate(new Command("migrate"), { effects: LOCAL_WRITE, mcp: false })
+    .summary("migrate an older local archive")
     .description("bring the store up to this build's schema, then normalize, index and stem the messages and notes stored before it")
     .action(async function () {
     const { renderer } = outputFor(this);
@@ -427,7 +431,8 @@ const buildNoteIndex = (database, note, { reset = false } = {}) => {
         note(`indexing ${pending} notes`);
     return { notesIndexed: drainNoteIndex(database, stemmerCache()) };
 };
-const reindexCommand = (messenger) => destroysNothing(annotate(new Command("reindex"), { effects: LOCAL_WRITE, mcp: false }))
+const reindexCommand = (messenger) => destroysNothing(annotate(new Command("reindex"), { effects: LOCAL_WRITE }))
+    .summary("rebuild the local archive's search indexes")
     .description("rebuild the word index, its typo vocabulary, the stems, the files' word index, the notes' indexes and who took part in what, from what is stored; loses nothing")
     .action(async function () {
     const { renderer } = outputFor(this);
@@ -540,6 +545,7 @@ const decryptCommand = () => annotate(new Command("decrypt"), { effects: LOCAL_W
  * `serve` runs: that opens the store on its first write, so until then it holds nothing to see.
  */
 const restoreCommand = (messenger) => annotate(new Command("restore"), { effects: LOCAL_WRITE, mcp: false })
+    .summary("restore a backup while keeping the current store")
     .description("put a backup in place of the store; the store it replaces is kept beside it, never deleted")
     .argument("<file>", "a file `store backup` wrote; one written with --encrypt asks for its password")
     .action(async function (file) {
@@ -656,6 +662,7 @@ const quiesce = async (path, messenger, then, warn, waitMs = STORE_LOCK_WAIT_MS)
  * schema. The backup is made before anything is deleted, and its path is said before the delete.
  */
 const resetCommand = (messenger) => annotate(new Command("reset"), { effects: LOCAL_WRITE, mcp: false })
+    .summary("back up the local archive and replace it with an empty one")
     .description("back the store up beside itself, then delete it and start an empty one at this build's schema; asks first, or --yes")
     .option("--no-backup", "delete the store without backing it up first")
     .action(async function ({ backup: keep }) {

package/dist/cli/messenger/tags-command.js

@@ -29,7 +29,9 @@ const sourceOf = (value) => {
 /** The owner's labels, in the local store only: `tag:` in a search finds what they label. */
 export const tagsCommand = (messenger) => {
     const tool = `${messenger.app.command} personal`;
-    const tags = new Command("tags").description("your own labels on chats, people, messages and tasks, kept in the local store and never sent; tag: in a search finds them");
+    const tags = new Command("tags")
+        .summary("tags on stored messages and other records")
+        .description("your own labels on chats, people, messages and tasks, kept in the local store and never sent; tag: in a search finds them");
     changesStore(annotate(tags.command("auto"), { effects: FETCH, examples: [`${tool} tags auto --chat "Book club" --dry-run`] }))
         .description("derive local group/channel tags from cached metadata using keyword rules")
         .option("--chat <chat>", "a stored group/channel; repeat to select several", (value, previous) => [...previous, value], [])
@@ -73,7 +75,9 @@ export const tagsCommand = (messenger) => {
     withQuery(annotate(tags.command("list"), {
         effects: LOCAL_READ,
         examples: [`${tool} tags list`, `${tool} tags list tag:reading`],
-    }).description("what is tagged: this account's chats, messages and tasks, and the people of its messenger"), TAGGING_QUERY).action(async function (words) {
+    })
+        .summary("tagged chats, people, messages and tasks")
+        .description("what is tagged: this account's chats, messages and tasks, and the people of its messenger"), TAGGING_QUERY).action(async function (words) {
         const context = messengerContext(this, messenger);
         const query = listQuery(typedQuery(words), TAGGING_QUERY, "tags list");
         const found = await context.withServices((services) => services.tags.list({ ...(query ? { query } : {}), ...pageOf(context.settings) }));

package/dist/cli/messenger/tasks-command.js

@@ -129,7 +129,9 @@ export const tasksCommand = (messenger) => {
     const writerOf = (command) => readOnlyLockOf(messenger.app, environmentOf(command).env ?? process.env) || environmentOf(command).agent
         ? "agent"
         : "owner";
-    const tasks = new Command("tasks").description("what waits on you — unanswered questions, mentions, requests, promises — kept in the local store; review and serve add them");
+    const tasks = new Command("tasks")
+        .summary("tasks found or kept in the local archive")
+        .description("what waits on you — unanswered questions, mentions, requests, promises — kept in the local store; review and serve add them");
     withQuery(annotate(tasks.command("list"), {
         effects: LOCAL_READ,
         examples: [`${tool} personal tasks list --limit 10`],
@@ -283,8 +285,8 @@ export const tasksCommand = (messenger) => {
     }))
         .summary("two tasks are not the same job: the pair is never offered again")
         .description("two tasks are not the same job: the pair leaves the list and is never offered again")
-        .argument("<dup>", "the task listed as the duplicate, by its id or key")
-        .argument("<task>", "the task it was paired with")
+        .argument("<task>", "the task listed as the duplicate, by its id or key")
+        .argument("<other-task>", "the task it was paired with")
         .action(decided("rejected", "tasks.duplicates.reject"));
     destroysNothing(annotate(duplicates.command("defer"), {
         effects: LOCAL_WRITE,
@@ -292,14 +294,14 @@ export const tasksCommand = (messenger) => {
     }))
         .summary("the fields and the text cannot tell: leave the pair to the owner")
         .description("the fields and the text cannot tell: leave the pair to the owner, who lists it with decision:unsure")
-        .argument("<dup>", "the task listed as the duplicate, by its id or key")
-        .argument("<task>", "the task it was paired with")
+        .argument("<task>", "the task listed as the duplicate, by its id or key")
+        .argument("<other-task>", "the task it was paired with")
         .action(decided("unsure", "tasks.duplicates.defer"));
     destroysNothing(annotate(tasks.command("merge"), { effects: LOCAL_WRITE, examples: [`${tool} tasks merge PR-14 --into PR-12`] }))
         .summary("one job seen twice: fold the duplicate into the task that stays")
         .description("one job seen twice: link every message of the duplicate to the task and close the duplicate dismissed, " +
         "duplicate-of the task; nothing is deleted, and tasks unmerge undoes it")
-        .argument("<dup>", "the duplicate, by its id or key; it must be open")
+        .argument("<task>", "the duplicate, by its id or key; it must be open")
         .requiredOption("--into <id>", "the task that stays, by its id or key")
         .action(async function (dup) {
         const context = messengerContext(this, messenger);
@@ -312,7 +314,7 @@ export const tasksCommand = (messenger) => {
     destroysNothing(annotate(tasks.command("unmerge"), { effects: LOCAL_WRITE, examples: [`${tool} tasks unmerge PR-14`] }))
         .summary("undo a merge: reopen the task and remove its duplicate-of relation")
         .description("undo a merge: reopen the task and remove its duplicate-of relation; messages the merge linked stay linked")
-        .argument("<dup>", "the merged task, by its id or key")
+        .argument("<task>", "the merged task, by its id or key")
         .action(async function (dup) {
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, "tasks.unmerge");
@@ -417,6 +419,7 @@ export const tasksCommand = (messenger) => {
         ],
     }))
         .summary("close a task: done, or dismissed when it needs no answer; an agent's unsure close waits on the owner")
+        .summary("close a task as done or dismissed")
         .description("close a task: done, or dismissed when it needs no answer. An agent (AI_AGENT or CLAUDECODE set) states its " +
         "--certainty; below config task_agent_close_min, or with task_agent_close off, the task stays open and the " +
         "close waits on the owner, who confirms it with tasks close or refuses it with tasks reject. A closed task " +

package/dist/cli/messenger/transcribe-command.js

@@ -12,6 +12,7 @@ export const transcribeSubcommand = (messages, messenger) => annotate(messages.c
     examples: [`${messenger.app.command} personal messages transcribe "Book club" 101`],
     effects: REMOTE_READ,
 })
+    .summary("transcribe one voice message")
     .description(`a voice message as text — by ${messenger.name ?? messenger.app.command} where it can, else by a model on this machine`)
     .argument("<chat>", messenger.chatArgument)
     .argument("<message>", "the id of a voice message")

package/dist/cli/messenger/watch-command.js

@@ -11,7 +11,12 @@ import { messengerContext } from "./context.js";
  * for a minute is a complete answer. One `MessageHit` per line with `--jsonl`; `--json` is refused,
  * because a stream is not one value. Nothing is marked read.
  */
-export const watchCommand = (messenger) => annotate(new Command("watch"), { effects: REMOTE_READ, lifetime: "persistent" })
+export const watchCommand = (messenger) => annotate(new Command("watch"), {
+    effects: REMOTE_READ,
+    lifetime: "persistent",
+    examples: [`${messenger.app.command} personal watch --jsonl --timeout 30s`],
+})
+    .summary("stream new messages until interrupted or timed out")
     .description("print new messages as they arrive, until Ctrl-C or --timeout (either ends it normally)")
     .option("--events", "also edits, deletions, reactions, poll votes and chat events; every line then names its event")
     .action(async function () {

package/dist/cli/runs/command.js

@@ -20,7 +20,6 @@ export const runsCommand = (app) => {
     };
     annotate(command.command("list"), {
         effects: LOCAL_READ,
-        mcp: false,
         examples: [`${app.command} runs list --limit 10`],
     })
         .description("recorded runs, newest first")
@@ -36,7 +35,7 @@ export const runsCommand = (app) => {
         if (runs.length === 0)
             renderer.note("nothing recorded — a run is kept with `--record`, or when it fails");
     });
-    annotate(command.command("show"), { effects: LOCAL_READ, mcp: false, examples: [`${app.command} runs show run-101`] })
+    annotate(command.command("show"), { effects: LOCAL_READ, examples: [`${app.command} runs show run-101`] })
         .argument("<run-id>", `an id from \`${app.command} runs list\``)
         .description("one run: what it was, how it ended, and every event it logged")
         .option("--problems", "only failed responses, warnings and crashes")
@@ -86,7 +85,7 @@ export const runsCommand = (app) => {
             since_time: options.sinceTime,
         }));
     });
-    annotate(command.command("path"), { effects: NO_EFFECTS, mcp: false, examples: [`${app.command} runs path run-101`] })
+    annotate(command.command("path"), { effects: NO_EFFECTS, examples: [`${app.command} runs path run-101`] })
         .argument("<run-id>", `an id from \`${app.command} runs list\``)
         .description("the directory holding one run")
         .action(function (id) {

package/dist/cli/skill-command.js

@@ -20,7 +20,7 @@ export const skillCommand = (app, skill) => {
     const show = command.commands.find((sub) => sub.name() === "show");
     if (show)
         annotate(show, { examples: [`${app.command} skill show`, `${app.command} skill show follow-ups`] });
-    return annotate(command, { mcp: false });
+    return command;
 };
 /** Skills this package ships for every CLI on it, printed by `skill show <name>`: `skills/` beside `dist/` and `src/`. */
 const SHARED_SKILLS = {

package/dist/domain/models.d.ts

@@ -506,6 +506,8 @@ export interface Review {
         closed: number;
         review: number;
     };
+    /** `--offline`: read from the local store, so it holds only what was already synced. */
+    offline?: true;
 }
 /** One change to who is in a chat, or to the chat itself, read from a service message. */
 export interface ChatEvent {

package/dist/entities/contact-read.d.ts

@@ -0,0 +1,119 @@
+import * as v from "valibot";
+export declare const contactLookup: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly username: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const contactSync: v.StrictObjectSchema<{
+    readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly changed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly known: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const contactProfile: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly usernames: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly bio: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly birthday: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly phone: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly flags: Omit<v.StrictObjectSchema<{
+        readonly bot: v.BooleanSchema<undefined>;
+        readonly verified: v.BooleanSchema<undefined>;
+        readonly premium: v.BooleanSchema<undefined>;
+        readonly scam: v.BooleanSchema<undefined>;
+        readonly fake: v.BooleanSchema<undefined>;
+        readonly restricted: v.BooleanSchema<undefined>;
+        readonly deleted: v.BooleanSchema<undefined>;
+        readonly support: v.BooleanSchema<undefined>;
+    }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+        readonly entries: {
+            readonly bot: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly verified: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly premium: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly scam: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly fake: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly restricted: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly deleted: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly support: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+            bot?: boolean | undefined;
+            verified?: boolean | undefined;
+            premium?: boolean | undefined;
+            scam?: boolean | undefined;
+            fake?: boolean | undefined;
+            restricted?: boolean | undefined;
+            deleted?: boolean | undefined;
+            support?: boolean | undefined;
+        }, {
+            bot?: boolean | undefined;
+            verified?: boolean | undefined;
+            premium?: boolean | undefined;
+            scam?: boolean | undefined;
+            fake?: boolean | undefined;
+            restricted?: boolean | undefined;
+            deleted?: boolean | undefined;
+            support?: boolean | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+            bot?: boolean | undefined;
+            verified?: boolean | undefined;
+            premium?: boolean | undefined;
+            scam?: boolean | undefined;
+            fake?: boolean | undefined;
+            restricted?: boolean | undefined;
+            deleted?: boolean | undefined;
+            support?: boolean | undefined;
+        }, v.BooleanIssue | v.StrictObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                bot?: boolean | undefined;
+                verified?: boolean | undefined;
+                premium?: boolean | undefined;
+                scam?: boolean | undefined;
+                fake?: boolean | undefined;
+                restricted?: boolean | undefined;
+                deleted?: boolean | undefined;
+                support?: boolean | undefined;
+            };
+            readonly output: {
+                bot?: boolean | undefined;
+                verified?: boolean | undefined;
+                premium?: boolean | undefined;
+                scam?: boolean | undefined;
+                fake?: boolean | undefined;
+                restricted?: boolean | undefined;
+                deleted?: boolean | undefined;
+                support?: boolean | undefined;
+            };
+            readonly issue: v.BooleanIssue | v.StrictObjectIssue;
+        } | undefined;
+    };
+    readonly seen: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly contact: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly mutual_contact: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly common_chats_count: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+    readonly registered: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
+        readonly at: v.StringSchema<undefined>;
+        readonly source: v.PicklistSchema<["telegram", "max", "estimate"], undefined>;
+        readonly precision: v.PicklistSchema<["day", "month"], undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly has_photo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly chats: v.ArraySchema<v.StrictObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly kind: v.PicklistSchema<["dialog", "group", "channel", "saved", "unknown"], undefined>;
+        readonly their_messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly first_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly last_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly complete: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly aliases: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly username: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly link: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly first_seen_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly last_seen_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly source: v.PicklistSchema<["profile", "messages"], undefined>;
+    }, undefined>, undefined>;
+}, undefined>;

package/dist/entities/contact-read.js

@@ -0,0 +1,50 @@
+import * as v from "valibot";
+import { chat } from "./chat.js";
+import { count, id, text, time } from "./fields.js";
+export const contactLookup = v.strictObject({ id, name: v.nullable(text), username: v.nullable(text) });
+export const contactSync = v.strictObject({ added: count, changed: count, known: count });
+export const contactProfile = v.strictObject({
+    id,
+    name: v.nullable(text),
+    usernames: v.array(text),
+    bio: v.nullable(text),
+    birthday: v.optional(v.nullable(text)),
+    phone: v.optional(v.nullable(text)),
+    flags: v.partial(v.strictObject({
+        bot: v.boolean(),
+        verified: v.boolean(),
+        premium: v.boolean(),
+        scam: v.boolean(),
+        fake: v.boolean(),
+        restricted: v.boolean(),
+        deleted: v.boolean(),
+        support: v.boolean(),
+    })),
+    seen: v.optional(text),
+    contact: v.optional(v.boolean()),
+    mutual_contact: v.optional(v.boolean()),
+    common_chats_count: v.optional(v.nullable(count)),
+    registered: v.optional(v.nullable(v.strictObject({
+        at: text,
+        source: v.picklist(["telegram", "max", "estimate"]),
+        precision: v.picklist(["day", "month"]),
+    }))),
+    has_photo: v.optional(v.boolean()),
+    chats: v.array(v.strictObject({
+        id,
+        title: v.nullable(text),
+        kind: chat.entries.kind,
+        their_messages: count,
+        first_at: v.nullable(time),
+        last_at: v.nullable(time),
+        complete: v.boolean(),
+    })),
+    aliases: v.array(v.strictObject({
+        name: v.optional(text),
+        username: v.optional(text),
+        link: v.optional(text),
+        first_seen_at: time,
+        last_seen_at: time,
+        source: v.picklist(["profile", "messages"]),
+    })),
+});