@wirecat/cli-core 0.360.0 → 0.361.0

package/CHANGELOG.md

@@ -7,6 +7,20 @@ shape of this file.
 
 ## Unreleased
 
+## 0.361.0 — 19.10.2026
+
+### Fixed
+
+- **A warning in `serve`'s log now says which warning it was.** Off a terminal, a re-key given up at exit, a write
+  the store did not take, a passive listen that failed and a stored-chats call that failed each wrote a bare
+  `serve.warning` record, so the log could not tell them apart. The record now carries the warning's `code`,
+  `operation` and `counts` (`rekeys_not_applied` with `counts.rekeys`), never its sentence, which can quote an
+  error or a chat. Warnings that have no code yet still log a bare record.
+- **The adapter test example in [ADAPTERS.md](docs/dev/ADAPTERS.md#running-the-contract-cases) no longer gives up
+  re-keys.** It handed `run()` `rekeyPacing: { lockMs: 0 }`, one re-key per transaction, so a few hundred re-keys
+  outlasted `closeWaitMs: 10` and were given up. It now hands `{ lockMs: 1000, pauseMs: 0 }` and says what each
+  field does.
+
 ## 0.360.0 — 19.10.2026
 
 ### Added

package/dist/cli/context.d.ts

@@ -37,7 +37,7 @@ export interface BaseEnvironment {
     storeLockWaitMs?: number;
     /** How long a connection's close waits on its saves and passive listens, 5 s unless a test hands one in. */
     closeWaitMs?: number;
-    /** How long one pass of chat re-keys holds the store's write lock and the pause after it; tests hand in zeros. */
+    /** How long one pass of chat re-keys holds the store's write lock and the pause after it; tests hand in no pause. */
     rekeyPacing?: {
         lockMs: number;
         pauseMs: number;

package/dist/cli/messenger/context.js

@@ -126,8 +126,9 @@ const listened = ({ run, operation, what }, events, warn, waitMs) => {
         .catch((error) => {
         if (closing)
             return;
-        events({ event: "warning", code: "listen_failed", operation });
-        warn(`${what} arriving during this command are not saved: ${error instanceof Error ? error.message : String(error)}`);
+        const warning = { event: "warning", code: "listen_failed", operation };
+        events(warning);
+        warn(`${what} arriving during this command are not saved: ${error instanceof Error ? error.message : String(error)}`, warning);
     });
     return {
         operation,
@@ -230,22 +231,22 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
             finally {
                 try {
                     const ended = await Promise.all(passives.map((passive) => passive.stop()));
+                    const warn = renderer.warn;
+                    const warned = (warning, text) => {
+                        events(warning);
+                        warn(text, warning);
+                    };
                     passives.forEach(({ operation, what }, at) => {
                         if (ended[at])
                             return;
-                        events({ event: "warning", code: "store_not_written", operation });
-                        renderer.warn(`not saved to the local store: the messenger was still handing on ${what} at exit`);
+                        warned({ event: "warning", code: "store_not_written", operation }, `not saved to the local store: the messenger was still handing on ${what} at exit`);
                     });
                     await settled(new Set([...pending, ...announcing]), closeWaitMs);
                     closing.abort();
-                    if (pending.size > 0) {
-                        events({ event: "warning", code: "store_not_written", operation: "close" });
-                        renderer.warn("not saved to the local store: the last messages were still being written at exit");
-                    }
-                    if (announcing.size > 0) {
-                        events({ event: "warning", code: "stored_chats_failed", operation: "close" });
-                        renderer.warn("the messenger's stored-chats hook did not finish and was abandoned at exit; nothing is lost");
-                    }
+                    if (pending.size > 0)
+                        warned({ event: "warning", code: "store_not_written", operation: "close" }, "not saved to the local store: the last messages were still being written at exit");
+                    if (announcing.size > 0)
+                        warned({ event: "warning", code: "stored_chats_failed", operation: "close" }, "the messenger's stored-chats hook did not finish and was abandoned at exit; nothing is lost");
                 }
                 finally {
                     await store.close();

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

@@ -13,8 +13,9 @@ export declare const noticeFor: (context: MessengerContext, app: AppIdentity, se
 /**
  * A serve left running writes its diagnostics to a log file, so off a terminal each one is a log record with
  * its time and run. A sentence handed to the renderer may quote an error or a chat, so the record keeps only
- * which kind of line it was; serve's own reports go through `noticeFor` with a code. The renderer is changed
- * in place, so the send guard, bound to it before serve started, writes records too.
+ * which kind of line it was, and a warning's code, operation and counts when the warning event comes with it
+ * (`Warn`); serve's own reports go through `noticeFor` with a code. The renderer is changed in place, so the
+ * send guard, bound to it before serve started, writes records too.
  */
 export declare const recordDiagnostics: (context: MessengerContext, app: AppIdentity) => MessengerContext;
 export {};

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

@@ -19,16 +19,18 @@ export const noticeFor = (context, app, severity = "warn") => ({ text, ...attrib
 /**
  * A serve left running writes its diagnostics to a log file, so off a terminal each one is a log record with
  * its time and run. A sentence handed to the renderer may quote an error or a chat, so the record keeps only
- * which kind of line it was; serve's own reports go through `noticeFor` with a code. The renderer is changed
- * in place, so the send guard, bound to it before serve started, writes records too.
+ * which kind of line it was, and a warning's code, operation and counts when the warning event comes with it
+ * (`Warn`); serve's own reports go through `noticeFor` with a code. The renderer is changed in place, so the
+ * send guard, bound to it before serve started, writes records too.
  */
 export const recordDiagnostics = (context, app) => {
     if (context.format === "pretty")
         return context;
-    const say = (severity, event, always = false) => (_text) => {
+    const say = (severity, event, always = false) => (_text, warning) => {
         if (context.settings.quiet && !always)
             return;
-        record(context, app, severity, { event });
+        const { event: _warning, ...fields } = warning ?? {};
+        record(context, app, severity, { event, ...fields });
     };
     const renderer = context.renderer;
     renderer.note = say("info", "serve.note");

package/dist/cli/messenger/stored.d.ts

@@ -1,13 +1,13 @@
 import type { Id } from "../../domain/models.js";
 import { type MessengerAdapter } from "../../ports/messenger.js";
 import type { MessengerTraits } from "../../ports/traits.js";
-import type { EventSink } from "../../runs/events.js";
+import type { EventSink, Warn } from "../../runs/events.js";
 import type { AccountKey, DeletionScope, MessageStore } from "../../store/store.js";
 export interface Saving {
     account: AccountKey;
     /** Opened on the first save, not before: a command that reads nothing has no reason to touch the file. */
     store: () => Promise<MessageStore | undefined>;
-    warn: (message: string) => void;
+    warn: Warn;
     events: EventSink;
     /** Saves still writing, for the closer to wait on: `watch` does not hold the next event for one. */
     pending?: Set<Promise<void>>;

package/dist/cli/messenger/stored.js

@@ -16,9 +16,10 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
     let warned = false;
     let recorded = profile === undefined;
     const notWritten = (operation, error) => {
-        events({ event: "warning", code: "store_not_written", operation });
+        const warning = { event: "warning", code: "store_not_written", operation };
+        events(warning);
         if (!warned)
-            warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`);
+            warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`, warning);
         warned = true;
     };
     const attempt = async (operation, write) => {
@@ -92,8 +93,14 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             pending?.delete(saving);
         if (count === 0)
             return;
-        events({ event: "warning", code: "rekeys_not_applied", operation: "history.rekey", counts: { rekeys: count } });
-        warn(`${count} chat re-key${count === 1 ? "" : "s"} not applied yet; the next serve applies them`);
+        const warning = {
+            event: "warning",
+            code: "rekeys_not_applied",
+            operation: "history.rekey",
+            counts: { rekeys: count },
+        };
+        events(warning);
+        warn(`${count} chat re-key${count === 1 ? "" : "s"} not applied yet; the next serve applies them`, warning);
     };
     closing?.addEventListener("abort", giveUpRekeys, { once: true });
     const saveRekeys = async (pairs, round) => {
@@ -466,8 +473,9 @@ const announceStoredChats = async (messenger, store, account, events, warn, reci
             await messenger.storedChats?.(held);
     }
     catch (error) {
-        events({ event: "warning", code: "stored_chats_failed", operation: "history.stored_chats" });
-        warn(`the messenger was not told the stored chats: ${error instanceof Error ? error.message : String(error)}`);
+        const warning = { event: "warning", code: "stored_chats_failed", operation: "history.stored_chats" };
+        events(warning);
+        warn(`the messenger was not told the stored chats: ${error instanceof Error ? error.message : String(error)}`, warning);
     }
 };
 /** Read once when `watch` starts: a store read per event would let a later event overtake an earlier one. */

package/dist/runs/events.d.ts

@@ -49,6 +49,8 @@ export interface CacheEvent {
 }
 export type DiagnosticEvent = RequestEvent | CacheEvent | WarningEvent;
 export type EventSink = (event: DiagnosticEvent) => void;
+/** A sentence for a person, and the warning event it stands for when there is one: a log record keeps only the event. */
+export type Warn = (message: string, warning?: WarningEvent) => void;
 /** `FLOOD_WAIT`, `PEER_ID_INVALID`, `login.token` — or nothing. A sentence is dropped, not trimmed. */
 export declare const providerErrorKey: (value: unknown) => string | undefined;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.360.0",
+  "version": "0.361.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",