@wirecat/cli-core 0.398.0 → 0.400.0

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

@@ -4,21 +4,25 @@ import { Command } from "commander";
 import { renderMessages } from "../../render/messages.js";
 import { environmentOf } from "../context.js";
 import { REMOTE_READ } from "../effects.js";
+import { jsonlRecords, listOf } from "../envelope.js";
 import { withoutProviderRefs } from "../provider-refs.js";
 import { messengerContext } from "./context.js";
+import { selfOf } from "./message-items.js";
+import { watchEventItem, watchedMessageItem } from "./watch-answers.js";
 /**
  * New messages as they arrive, until Ctrl-C or `--timeout` — both a normal end, exit 0: listening
- * for a minute is a complete answer. One `MessageHit` per line with `--jsonl`; `--json` is refused,
+ * for a minute is a complete answer. Canonical item records and one end record with `--jsonl`; `--json` is refused,
  * because a stream is not one value. Nothing is marked read.
  */
 export const watchCommand = (messenger) => annotate(new Command("watch"), {
+    output: { entity: "watch_item" },
     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")
+    .option("--events", "include changes and receipts; each item names its event")
     .action(async function () {
     const events = this.opts().events === true;
     const context = messengerContext(this, messenger);
@@ -35,19 +39,59 @@ export const watchCommand = (messenger) => annotate(new Command("watch"), {
         provider: messenger.provider,
         locale: messenger.app.locale,
     })}`;
-    // Without --events the stream is bare messages, as it always was: a reader of it never meets
-    // a line of another shape.
+    // Event-tagged payloads are opt-in; ordinary items remain message values.
     const stop = new AbortController();
+    let connection;
+    let printed = 0;
+    const account = () => {
+        if (!connection)
+            throw new Error("watch has no connected account");
+        return selfOf(messenger, connection);
+    };
     const print = (event) => {
         if (stop.signal.aborted || (!events && event.event !== "message"))
             return;
         if (context.format === "jsonl") {
-            context.streams.data(JSON.stringify(withoutProviderRefs(events ? event : event.message)));
+            const data = events
+                ? watchEventItem(event, account())
+                : event.event === "message"
+                    ? watchedMessageItem(event.message, account())
+                    : undefined;
+            if (data === undefined)
+                return;
+            context.streams.data(JSON.stringify({ type: "item", data: withoutProviderRefs(data) }));
+            printed++;
         }
         else
             context.streams.data(describe(event, render));
     };
-    await listenUntilStopped(this, context, messenger, print, { stop, pipe: true });
+    const finish = (complete, error) => {
+        if (context.format !== "jsonl" || environmentOf(this).commandSignal?.aborted)
+            return;
+        const issues = !complete && error instanceof CliError ? [{ code: error.code, source: "watch" }] : undefined;
+        for (const record of jsonlRecords(listOf("watch", {
+            items: [],
+            limit: Math.max(1, printed),
+            has_more: false,
+            paging: "cursor",
+            meta: { complete, ...(issues ? { issues } : {}) },
+        })))
+            context.streams.data(JSON.stringify(record));
+    };
+    try {
+        await listenUntilStopped(this, context, messenger, print, {
+            stop,
+            pipe: true,
+            connected: (open) => {
+                connection = open;
+            },
+        });
+    }
+    catch (error) {
+        finish(false, error);
+        throw error;
+    }
+    finish(true);
 });
 /**
  * Listens until Ctrl-C, SIGTERM, `--timeout` or — with `pipe` — a reader that has gone away.
@@ -55,7 +99,11 @@ export const watchCommand = (messenger) => annotate(new Command("watch"), {
  * `feed` runs it beside `watch`, so what the messenger pushes reaches the store (`stored`).
  */
 export const listenUntilStopped = async (command, context, messenger, onEvent, { stop, pipe = false, catchUp = false, onReady = () => context.renderer.note("listening — Ctrl-C to stop"), connected, }) => {
-    const given = environmentOf(command).signal;
+    const environment = environmentOf(command);
+    const phase = environment.untilStopped?.();
+    const given = phase
+        ? AbortSignal.any([phase, ...[environment.signal].filter((one) => one !== undefined)])
+        : environment.signal;
     const end = () => stop.abort();
     given?.addEventListener("abort", end, { once: true });
     const signals = given ? [] : ["SIGINT", "SIGTERM"];
@@ -96,6 +144,7 @@ export const listenUntilStopped = async (command, context, messenger, onEvent, {
         if (pipe && !given)
             process.stdout.off("error", closed);
         given?.removeEventListener("abort", end);
+        environment.endUntilStopped?.();
     }
 };
 const describe = (event, render) => {

package/dist/cli/program.js

@@ -11,7 +11,7 @@ import { failureContext } from "../errors/reasons.js";
 import { envName, readOnlyLockOf, readOnlyRefusal } from "../ports/app.js";
 import { recorded, wasSettled } from "../runs/recording.js";
 import { processRun, useAsProcessRun } from "../runs/scope.js";
-import { keyForCommand } from "../sends/permissions.js";
+import { AUTHORITY_KEY, keyForCommand } from "../sends/permissions.js";
 import { logParsedArgv, logVersion } from "./argv-log.js";
 import { commandPathOf } from "./command-contract.js";
 import { outputFor, provide } from "./context.js";
@@ -254,6 +254,10 @@ const runOnce = async (argv, definition, options) => {
         if (lock && changesAuthorityNow(action) && !flags.dryRun)
             throw new CliError("permission_error", `this process is read-only (${lock}) — \`${command} ${path.join(" ")}\` changes what a later run may do; ` +
                 `run it without ${lock}`);
+        if (options.agent && options.agent.authority !== true && changesAuthorityNow(action))
+            throw new CliError("permission_error", `\`${command} ${path.join(" ")}\` changes what a later run may do, and this profile keeps that from agents ` +
+                `(${AUTHORITY_KEY}) — the owner turns it on in a terminal: ` +
+                `\`${command} <profile> config set${path[0] === "bot" ? " --bot" : ""} permissions.${AUTHORITY_KEY} allow\``, { permission: AUTHORITY_KEY, sent: false });
         const { lifetime, cooperative: stopsAtItsPace } = metaOf(action);
         const persistent = lifetime === "persistent";
         listens = persistent;

package/dist/cli/runs/command.js

@@ -1,13 +1,14 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command, Option } from "commander";
+import { Command } from "commander";
 import { findRun, listRuns, readEvents, runsDirFor } from "../../runs/run.js";
 import { environmentOf, outputFor } from "../context.js";
 import { LOCAL_READ, NO_EFFECTS } from "../effects.js";
 import { itemOf, listOf, renderAnswer, snakeKeys } from "../envelope.js";
+import { typedQuery, withQuery } from "../list-query.js";
 import { positiveCount } from "../paging.js";
 import { lineOf } from "../steps.js";
-import { runsFound, searchRuns } from "./search.js";
+import { RUNS_QUERY, runListFilter } from "./query.js";
 /** Reading the log is not itself worth recording, so **nothing here starts a run**. */
 export const runsCommand = (app) => {
     const command = new Command("runs").description("recorded runs — what this tool did, and when");
@@ -18,24 +19,35 @@ export const runsCommand = (app) => {
             throw new CliError("not_found", `no recorded run "${id}" — \`${lineOf(from, "runs list")}\` shows them`);
         return found;
     };
-    annotate(command.command("list"), {
-        effects: LOCAL_READ,
+    withQuery(annotate(command.command("list"), {
         examples: [`${app.command} runs list --limit 10`],
-    })
+        effects: LOCAL_READ,
+    }), RUNS_QUERY)
         .description("recorded runs, newest first")
         .option("--limit <n>", "how many to show", positiveCount("--limit"), 20)
         .option("--page <n>", "which page, starting at 1", positiveCount("--page"), 1)
-        .action(function () {
+        .action(function (words) {
+        const filter = runListFilter(words);
         const { limit, page } = this.opts();
         const output = outputFor(this);
         const { renderer } = output;
-        const runs = listRuns(dir(this), { atLeast: page * limit + 1 });
+        const runs = listRuns(dir(this), { atLeast: page * limit + 1, filter });
         const shown = runs.slice((page - 1) * limit, page * limit);
-        renderAnswer(this, output, listOf("runs list", { items: shown.map(snakeKeys), limit, page, has_more: runs.length > page * limit }));
+        renderAnswer(this, output, listOf("runs list", {
+            items: shown.map(snakeKeys),
+            limit,
+            page,
+            has_more: runs.length > page * limit,
+            args: words.length ? { query: typedQuery(words) } : {},
+        }));
         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, examples: [`${app.command} runs show run-101`] })
+    annotate(command.command("show"), {
+        examples: [`${app.command} runs show run-101`],
+        effects: LOCAL_READ,
+        output: { entity: "run", view: "details" },
+    })
         .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")
@@ -56,36 +68,11 @@ export const runsCommand = (app) => {
         if (shown.length < events.length)
             renderer.note(`${events.length - shown.length} other events — \`${lineOf(this, `runs show ${id}`)}\` shows them all`);
     });
-    annotate(command.command("search"), {
-        effects: LOCAL_READ,
-        examples: [`${app.command} runs search timeout --limit 10`],
+    annotate(command.command("path"), {
+        examples: [`${app.command} runs path run-101`],
+        effects: NO_EFFECTS,
+        output: { entity: "run_location" },
     })
-        .description("search recorded diagnostic metadata and events; no message contents")
-        .argument("[query]", "case-insensitive literal diagnostic text")
-        .addOption(new Option("--status <status>", "run outcome").choices(["success", "failed", "partial", "running"]))
-        .option("--error-code <code>", "one stable error code")
-        .option("--operation <name>", "one operation, such as messages.download")
-        .option("--profile <name>", "one recorded profile")
-        .option("--since-time <time>", "runs starting on or after an ISO time or 2h / 1d ago")
-        .option("--limit <n>", "matches per page, at most 100", positiveCount("--limit"), 20)
-        .option("--page <n>", "result page", positiveCount("--page"), 1)
-        .action(function (query) {
-        const options = this.opts();
-        const found = searchRuns(dir(this), {
-            ...options,
-            since: options.sinceTime,
-            ...(query === undefined ? {} : { query }),
-        });
-        renderAnswer(this, outputFor(this), runsFound(found, {
-            query,
-            status: options.status,
-            error_code: options.errorCode,
-            operation: options.operation,
-            profile: options.profile,
-            since_time: options.sinceTime,
-        }));
-    });
-    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/runs/query.d.ts

@@ -0,0 +1,5 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+import type { RunListFilter } from "../../runs/run.js";
+import { type QueryWords } from "../list-query.js";
+export declare const RUNS_QUERY: QueryRegistry;
+export declare const runListFilter: (words: QueryWords) => RunListFilter;

package/dist/cli/runs/query.js

@@ -0,0 +1,32 @@
+import { queryFieldsOf } from "@wirecat/cli-base/query";
+import { recordedRun } from "../../entities/index.js";
+import { queryTerms } from "../list-query.js";
+export const RUNS_QUERY = {
+    entity: "run",
+    backend: "native",
+    fields: queryFieldsOf(recordedRun, {
+        native: ["run_id", "command", "profile", "status", "error_code"],
+        examples: {
+            command: 'command:"messages send"',
+            profile: "profile:work",
+            status: "status:failed",
+            error_code: "error_code:timeout",
+        },
+    }).map((field) => field.native
+        ? {
+            ...field,
+            operators: field.operators.filter((operator) => operator === "term" || operator === "phrase"),
+        }
+        : field),
+};
+export const runListFilter = (words) => {
+    const terms = queryTerms(words, RUNS_QUERY, "runs list");
+    const status = recordedRun.entries.status.options.find((value) => value === terms.get("status"));
+    return {
+        ...(terms.has("run_id") ? { runId: terms.get("run_id") } : {}),
+        ...(terms.has("command") ? { command: terms.get("command") } : {}),
+        ...(terms.has("profile") ? { profile: terms.get("profile") } : {}),
+        ...(status === undefined ? {} : { status }),
+        ...(terms.has("error_code") ? { errorCode: terms.get("error_code") } : {}),
+    };
+};

package/dist/cli/runs/search-command.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import type { AppIdentity } from "../../ports/app.js";
+/** Diagnostic files are independent of linked accounts and never start a recorded run themselves. */
+export declare const runsSearchCommand: (app: AppIdentity) => Command;

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

@@ -0,0 +1,27 @@
+import { annotate } from "@wirecat/cli-base/commands";
+import { Command } from "commander";
+import { runsDirFor } from "../../runs/run.js";
+import { environmentOf, outputFor } from "../context.js";
+import { LOCAL_READ } from "../effects.js";
+import { renderAnswer } from "../envelope.js";
+import { typedQuery, withQuery } from "../list-query.js";
+import { positiveCount } from "../paging.js";
+import { runsFound, searchRuns } from "./search.js";
+import { RUN_SEARCH_QUERY, runSearchFilter } from "./search-query.js";
+/** Diagnostic files are independent of linked accounts and never start a recorded run themselves. */
+export const runsSearchCommand = (app) => annotate(withQuery(new Command("runs")
+    .summary("search recorded diagnostic metadata and events")
+    .description("search recorded diagnostic metadata and events; literal words and field:value terms joined by AND; no message contents")
+    .option("--since-time <time>", "runs starting on or after an ISO time or 2h / 1d ago")
+    .option("--limit <n>", "matches per page, at most 100", positiveCount("--limit"), 20)
+    .option("--page <n>", "result page", positiveCount("--page"), 1), RUN_SEARCH_QUERY), {
+    effects: LOCAL_READ,
+    output: { entity: "run", view: "hit" },
+    examples: [`${app.command} search runs timeout status:failed --limit 10`],
+}).action(function (words) {
+    const filter = runSearchFilter(words);
+    const options = this.opts();
+    const dir = runsDirFor(app, environmentOf(this).env ?? process.env);
+    const found = searchRuns(dir, { ...filter, ...options, since: options.sinceTime });
+    renderAnswer(this, outputFor(this), runsFound(found, { query: typedQuery(words), since_time: options.sinceTime }));
+});

package/dist/cli/runs/search-query.d.ts

@@ -0,0 +1,4 @@
+import { type QueryWords } from "../list-query.js";
+import type { RunSearch } from "./search.js";
+export declare const RUN_SEARCH_QUERY: import("@wirecat/cli-base/query").QueryRegistry;
+export declare const runSearchFilter: (words: QueryWords) => Pick<RunSearch, "terms" | "status" | "errorCode" | "operation" | "profile">;

package/dist/cli/runs/search-query.js

@@ -0,0 +1,50 @@
+import { defineQuery, parseLucene, queryError, validateQuery } from "@wirecat/cli-base/query";
+import { LIST_QUERY_GUIDE, termField, typedQuery } from "../list-query.js";
+export const RUN_SEARCH_QUERY = defineQuery({
+    entity: "run",
+    backend: "native",
+    fields: [
+        termField("text", "kw", "text:timeout"),
+        termField("status", "enum", "status:failed", { values: ["success", "failed", "partial", "running"] }),
+        termField("error_code", "kw", "error_code:rate_limited"),
+        termField("operation", "kw", "operation:messages.download"),
+        termField("profile", "kw", "profile:work"),
+    ],
+});
+export const runSearchFilter = (words) => {
+    const text = typedQuery(words).trim();
+    if (!text)
+        return {};
+    const context = { command: "search runs", guide: LIST_QUERY_GUIDE };
+    const ast = parseLucene(text, { defaultField: "text", ...context });
+    validateQuery(ast, RUN_SEARCH_QUERY, context);
+    const terms = [];
+    const fields = new Map();
+    const add = (node) => {
+        if (node.kind === "boolean") {
+            for (const clause of node.clauses) {
+                if (clause.occur !== "must")
+                    queryError("query.unsupported-placement", clause.node.span, "run search takes terms joined by AND", context);
+                add(clause.node);
+            }
+            return;
+        }
+        if (node.operator !== "term" && node.operator !== "phrase")
+            queryError("query.unsupported-placement", node.span, "run search takes literal words and field:value terms", context);
+        if (node.field === "text")
+            terms.push(node.value);
+        else {
+            if (fields.has(node.field))
+                queryError("query.unsupported-placement", node.span, `${node.field} only once here`, context);
+            fields.set(node.field, node.value);
+        }
+    };
+    add(ast.root);
+    return {
+        ...(terms.length ? { terms } : {}),
+        ...(fields.has("status") ? { status: fields.get("status")?.toLowerCase() } : {}),
+        ...(fields.has("error_code") ? { errorCode: fields.get("error_code") } : {}),
+        ...(fields.has("operation") ? { operation: fields.get("operation") } : {}),
+        ...(fields.has("profile") ? { profile: fields.get("profile") } : {}),
+    };
+};

package/dist/cli/runs/search.d.ts

@@ -1,5 +1,6 @@
 export interface RunSearch {
     query?: string;
+    terms?: readonly string[];
     status?: "success" | "failed" | "partial" | "running";
     errorCode?: string;
     operation?: string;
@@ -8,7 +9,7 @@ export interface RunSearch {
     limit?: number;
     page?: number;
 }
-export declare const searchRuns: (dir: string, { query, status, errorCode, operation, profile, since, limit, page }?: RunSearch) => {
+export declare const searchRuns: (dir: string, { query, terms, status, errorCode, operation, profile, since, limit, page }?: RunSearch) => {
     items: {
         runId: string;
         command: string;

package/dist/cli/runs/search.js

@@ -32,14 +32,14 @@ const safeEvent = (event) => Object.fromEntries(FIELDS.flatMap((name) => {
     }
     return typeof value === "string" || typeof value === "number" ? [[name, value]] : [];
 }));
-export const searchRuns = (dir, { query = "", status, errorCode, operation, profile, since, limit = 20, page = 1 } = {}) => {
+export const searchRuns = (dir, { query = "", terms = [], status, errorCode, operation, profile, since, limit = 20, page = 1 } = {}) => {
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(page) || page < 1)
         throw new CliError("validation_error", "run search uses a limit from 1 to 100 and a positive page");
     const window = dateWindow(since === undefined ? {} : { sinceTime: since });
     const from = window.since;
     if (from !== undefined && !Number.isFinite(from))
         throw new CliError("validation_error", "--since-time must be a valid date or ISO timestamp");
-    const needle = query.toLowerCase();
+    const needles = [...(query ? [query] : []), ...terms].map((term) => term.toLowerCase());
     const offset = (page - 1) * limit;
     const matches = [];
     for (const run of listRuns(dir, from === undefined ? {} : { since: from })) {
@@ -51,11 +51,11 @@ export const searchRuns = (dir, { query = "", status, errorCode, operation, prof
             run.errorCode === errorCode ||
             run.partial?.failures.some((failure) => failure.errorCode === errorCode)) &&
             !operation &&
-            (!needle || JSON.stringify(run).toLowerCase().includes(needle));
+            needles.every((needle) => JSON.stringify(run).toLowerCase().includes(needle));
         // A finished run lists its operations and codes, so a run that cannot match is never opened.
         // One still running, or killed, has no such list and is read.
         const ruledOut = !metadataMatch &&
-            !needle &&
+            needles.length === 0 &&
             ((operation !== undefined && run.operations !== undefined && !run.operations.includes(operation)) ||
                 (errorCode !== undefined && run.codes !== undefined && !run.codes.includes(errorCode)));
         if (ruledOut)
@@ -64,7 +64,7 @@ export const searchRuns = (dir, { query = "", status, errorCode, operation, prof
         const events = found ? readEvents(found.dir).map(safeEvent) : [];
         const filtered = events.filter((event) => (!errorCode || event.error_code === errorCode || event.code === errorCode) &&
             (!operation || event.operation === operation) &&
-            (!needle || JSON.stringify(event).toLowerCase().includes(needle)));
+            needles.every((needle) => JSON.stringify(event).toLowerCase().includes(needle)));
         if (!metadataMatch && filtered.length === 0)
             continue;
         const metadata = {
@@ -110,7 +110,7 @@ export const searchRuns = (dir, { query = "", status, errorCode, operation, prof
     };
 };
 /** A page of `searchRuns` in the list envelope; `args` are the search's own, so `page.next` reruns it. */
-export const runsFound = (found, args) => listOf("runs search", {
+export const runsFound = (found, args) => listOf("search runs", {
     items: found.items.map(snakeKeys),
     limit: found.limit,
     has_more: found.hasMore,

package/dist/domain/attachments.js

@@ -1,5 +1,13 @@
 /** Attachments that are never a file, so their messages cost no download request. */
-export const NOT_FILES = new Set(["webpage", "share", "poll", "location", "contact"]);
+export const NOT_FILES = new Set([
+    "webpage",
+    "share",
+    "poll",
+    "location",
+    "contact",
+    "control",
+    "inline_keyboard",
+]);
 /** The stored kinds `has:<kind>` matches: MAX stores a file as `file`, Telegram as `document`. */
 export const storedKinds = (kind) => (kind === "file" ? ["file", "document"] : [kind]);
 /**

package/dist/domain/rankings-options.js

@@ -33,11 +33,11 @@ export const rankingOptions = (target, input) => {
     const { measure, score, weights: given, minMessages } = input;
     const messageKind = input.messageKind ?? "all";
     if (!["all", "posts", "comments"].includes(messageKind))
-        invalid("--message-kind takes all, posts or comments");
+        invalid("message_kind takes all, posts or comments");
     if (target === "messages" && minMessages !== undefined)
-        invalid("--min-messages applies to stats contacts top");
+        invalid("min_messages applies to stats contacts top");
     if (minMessages !== undefined && (!Number.isSafeInteger(minMessages) || minMessages < 1))
-        invalid("--min-messages takes a positive integer");
+        invalid("min_messages takes a positive integer");
     if (measure !== undefined && !measures.includes(measure))
         invalid(`--measure takes ${measures.join(", ")}`);
     if (measure !== undefined && (score !== undefined || given !== undefined))

package/dist/entities/account-change.d.ts

@@ -0,0 +1,89 @@
+import * as v from "valibot";
+export declare const accountChange: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly account: Omit<v.StrictObjectSchema<{
+        readonly provider: v.StringSchema<undefined>;
+        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>;
+        readonly phone: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly scope: v.OptionalSchema<v.PicklistSchema<["personal", "work"], undefined>, undefined>;
+    }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+        readonly entries: Omit<{
+            readonly provider: v.StringSchema<undefined>;
+            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>;
+            readonly phone: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly scope: v.OptionalSchema<v.PicklistSchema<["personal", "work"], undefined>, undefined>;
+        }, "provider" | "scope">;
+        readonly "~standard": v.StandardProps<{
+            id: string;
+            name: string | null;
+            username: string | null;
+            phone?: string | null | undefined;
+        }, {
+            id: string;
+            name: string | null;
+            username: string | null;
+            phone?: string | null | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+            id: string;
+            name: string | null;
+            username: string | null;
+            phone?: string | null | undefined;
+        }, v.MinLengthIssue<string, 1> | v.StrictObjectIssue | v.StringIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                id: string;
+                name: string | null;
+                username: string | null;
+                phone?: string | null | undefined;
+            };
+            readonly output: {
+                id: string;
+                name: string | null;
+                username: string | null;
+                phone?: string | null | undefined;
+            };
+            readonly issue: v.MinLengthIssue<string, 1> | v.StrictObjectIssue | v.StringIssue;
+        } | undefined;
+    };
+}, undefined>;
+export declare const endedAccountSessions: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly sessions: v.ArraySchema<v.StrictObjectSchema<{
+        readonly current: v.BooleanSchema<undefined>;
+        readonly client: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly device: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly location: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly last_active_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 created_at: v.OptionalSchema<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>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const accountPrivacy: v.StrictObjectSchema<{
+    readonly find_by_phone: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+    readonly phone_number: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+    readonly calls: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+    readonly chat_invites: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+    readonly hide_online: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly read_receipts: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly profile_photo: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody", "contacts_except"], undefined>, undefined>;
+    readonly about: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody", "contacts_except"], undefined>, undefined>;
+    readonly last_seen: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody", "contacts_except"], undefined>, undefined>;
+}, undefined>;
+export declare const accountPrivacyChange: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly privacy: v.StrictObjectSchema<{
+        readonly find_by_phone: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+        readonly phone_number: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+        readonly calls: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+        readonly chat_invites: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody"], undefined>, undefined>;
+        readonly hide_online: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly read_receipts: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly profile_photo: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody", "contacts_except"], undefined>, undefined>;
+        readonly about: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody", "contacts_except"], undefined>, undefined>;
+        readonly last_seen: v.OptionalSchema<v.PicklistSchema<["everyone", "contacts", "nobody", "contacts_except"], undefined>, undefined>;
+    }, undefined>;
+}, undefined>;

package/dist/entities/account-change.js

@@ -0,0 +1,20 @@
+import * as v from "valibot";
+import { account } from "./account.js";
+import { accountSession } from "./account-session.js";
+import { id } from "./fields.js";
+export const accountChange = v.strictObject({ operation_id: id, account: v.omit(account, ["provider", "scope"]) });
+export const endedAccountSessions = v.strictObject({ operation_id: id, sessions: v.array(accountSession) });
+const audience = v.picklist(["everyone", "contacts", "nobody"]);
+const shownAudience = v.picklist(["everyone", "contacts", "nobody", "contacts_except"]);
+export const accountPrivacy = v.strictObject({
+    find_by_phone: v.optional(audience),
+    phone_number: v.optional(audience),
+    calls: v.optional(audience),
+    chat_invites: v.optional(audience),
+    hide_online: v.optional(v.boolean()),
+    read_receipts: v.optional(v.boolean()),
+    profile_photo: v.optional(shownAudience),
+    about: v.optional(shownAudience),
+    last_seen: v.optional(shownAudience),
+});
+export const accountPrivacyChange = v.strictObject({ operation_id: id, privacy: accountPrivacy });

package/dist/entities/account-profile.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const accountProfile: v.StrictObjectSchema<{
+    readonly profile: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly current: v.BooleanSchema<undefined>;
+    readonly account: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;

package/dist/entities/account-profile.js

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+import { id, text } from "./fields.js";
+export const accountProfile = v.strictObject({
+    profile: id,
+    current: v.boolean(),
+    account: v.nullable(id),
+    name: v.nullable(text),
+});

package/dist/entities/analysis-consent.d.ts

@@ -0,0 +1,9 @@
+import * as v from "valibot";
+export declare const analysisConsent: v.StrictObjectSchema<{
+    readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly provider: v.StringSchema<undefined>;
+    readonly 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`">]>;
+}, undefined>;
+export declare const analysisConsentRevocation: v.StrictObjectSchema<{
+    readonly revoked: v.BooleanSchema<undefined>;
+}, undefined>;

package/dist/entities/analysis-consent.js

@@ -0,0 +1,4 @@
+import * as v from "valibot";
+import { id, text, time } from "./fields.js";
+export const analysisConsent = v.strictObject({ chat: id, provider: text, at: time });
+export const analysisConsentRevocation = v.strictObject({ revoked: v.boolean() });