@k2b/cloud 0.23.0 → 0.24.0

package/src/shared/markdown/formula.ts

@@ -475,6 +475,76 @@ const isTruthy = (v: EvalValue): boolean => {
   return v.length > 0;
 };
 
+/** Cell text that is one decimal number and nothing else. Each digit has
+ *  one place in the pattern, so a long run of digits never backtracks. */
+const NUMBER_CELL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+
+/** A number, boolean, or text whose whole content is one number. */
+const toExactNumber = (v: EvalValue): number | null =>
+  typeof v === "string" ? (NUMBER_CELL.test(v.trim()) ? Number(v.trim()) : null) : toNumber(v);
+
+/** An ISO date or timestamp: `2026-10-12`, `2026-10-12 09:30`,
+ *  `2026-10-12T09:30:00.250Z`, or with an offset such as `+02:00`. */
+const ISO_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3})\d*)?)?(Z|[+-]\d{2}:?\d{2})?)?$/i;
+
+/** An ISO date without a time, such as `2026-10-12`. */
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * The instant an ISO date or timestamp names, or null for anything else,
+ * including impossible dates such as `2026-02-30` and offsets such as
+ * `+00:60`. Text without an offset is local time, like the values TODAY()
+ * and NOW() return.
+ */
+const toDateTime = (v: EvalValue): number | null => {
+  if (typeof v !== "string") return null;
+  const match = ISO_DATE_TIME.exec(v.trim());
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4] ?? 0);
+  const minute = Number(match[5] ?? 0);
+  const second = Number(match[6] ?? 0);
+  const ms = Number((match[7] ?? "").padEnd(3, "0"));
+  const zone = match[8];
+  if (hour > 23 || minute > 59 || second > 59) return null;
+  const utc = new Date(0);
+  utc.setUTCFullYear(year, month - 1, day);
+  if (utc.getUTCMonth() !== month - 1 || utc.getUTCDate() !== day) return null;
+  if (zone) {
+    utc.setUTCHours(hour, minute, second, ms);
+    if (zone.toUpperCase() === "Z") return utc.getTime();
+    const sign = zone.startsWith("-") ? -1 : 1;
+    const digits = zone.slice(1).replace(":", "");
+    const offsetHours = Number(digits.slice(0, 2));
+    const offsetMinutes = Number(digits.slice(2));
+    if (offsetHours > 23 || offsetMinutes > 59) return null;
+    return utc.getTime() - sign * (offsetHours * 60 + offsetMinutes) * 60_000;
+  }
+  const local = new Date(0);
+  local.setFullYear(year, month - 1, day);
+  local.setHours(hour, minute, second, ms);
+  return local.getTime();
+};
+
+/**
+ * Equality for `==`, `!=`, COUNTIF, and SUMIF: dates by instant; numbers,
+ * also `5 €` against 5, by value; everything else, such as `1.2.3` or
+ * `3 apples`, by its exact text.
+ */
+const isEqual = (l: EvalValue, r: EvalValue): boolean => {
+  const ld = toDateTime(l);
+  const rd = toDateTime(r);
+  if (ld !== null && rd !== null) return ld === rd;
+  if (ld === null && rd === null && (toExactNumber(l) !== null || toExactNumber(r) !== null)) {
+    const ln = toNumber(l);
+    const rn = toNumber(r);
+    if (ln !== null && rn !== null) return ln === rn;
+  }
+  return toString(l) === toString(r);
+};
+
 const lookupColumn = (name: string, ctx: EvalContext): { index: number } | { suggestion?: string } => {
   const lower = name.toLowerCase();
   const idx = ctx.headers.findIndex((h) => h.toLowerCase() === lower);
@@ -492,8 +562,9 @@ const isCurrentFormulaCell = (row: number, col: number, ctx: EvalContext): boole
 /**
  * Resolve a single cell to its evaluated value. If the cell is itself
  * a formula, recursively evaluate it (with cycle detection via
- * `ctx._visited`). Non-formula cells are coerced to number when
- * possible, otherwise returned as-is.
+ * `ctx._visited`). A non-formula cell becomes a number only when its
+ * whole text is one; anything else, such as the ISO date `2026-10-12`
+ * that DATEDIFF needs intact, stays text.
  *
  * Used by both the column-reference resolver in `evaluateAst` and by
  * the column / row aggregate functions, so a `=SUM(total)` aggregating
@@ -503,8 +574,8 @@ const isCurrentFormulaCell = (row: number, col: number, ctx: EvalContext): boole
 const evaluateCell = (row: number, col: number, ctx: EvalContext): EvalResult => {
   const cell = cellAt(row, col, ctx);
   if (!cell.startsWith("=")) {
-    const n = toNumber(cell);
-    return n !== null ? ok(n) : ok(cell);
+    const text = cell.trim();
+    return NUMBER_CELL.test(text) ? ok(Number(text)) : ok(cell);
   }
   const key = `${row},${col}`;
   if (ctx._visited?.has(key)) {
@@ -686,9 +757,8 @@ const FUNCTIONS: Record<string, FuncImpl> = {
     if ("kind" in col) return col;
     const valueArg = state.evaluate(args[1]!);
     if (valueArg.kind === "error") return valueArg;
-    const target = toString(valueArg.value);
     let count = 0;
-    for (const v of col.values) if (v === target) count++;
+    for (const v of col.values) if (isEqual(v, valueArg.value)) count++;
     return ok(count);
   },
   SUMIF: (args, state) => {
@@ -717,13 +787,12 @@ const FUNCTIONS: Record<string, FuncImpl> = {
     }
     const condValueArg = state.evaluate(args[2]!);
     if (condValueArg.kind === "error") return condValueArg;
-    const target = toString(condValueArg.value);
     let total = 0;
     for (let r = 0; r < state.ctx.rows.length; r++) {
       if (isCurrentFormulaCell(r, condLookup.index, state.ctx) || isCurrentFormulaCell(r, sumLookup.index, state.ctx)) continue;
       const condResult = evaluateCell(r, condLookup.index, state.ctx);
       if (condResult.kind !== "ok") continue;
-      if (toString(condResult.value) !== target) continue;
+      if (!isEqual(condResult.value, condValueArg.value)) continue;
       const sumResult = evaluateCell(r, sumLookup.index, state.ctx);
       if (sumResult.kind !== "ok") continue;
       const n = toNumber(sumResult.value);
@@ -989,17 +1058,25 @@ const FUNCTIONS: Record<string, FuncImpl> = {
     if (d1V.kind === "error") return d1V;
     const d2V = state.evaluate(args[1]!);
     if (d2V.kind === "error") return d2V;
-    const d1 = new Date(toString(d1V.value));
-    const d2 = new Date(toString(d2V.value));
-    if (Number.isNaN(d1.getTime())) return err("PARSE_ERROR", `DATEDIFF: first argument is not a valid date`);
-    if (Number.isNaN(d2.getTime())) return err("PARSE_ERROR", `DATEDIFF: second argument is not a valid date`);
+    // ISO values follow the comparison operators, so a date without a
+    // time is local midnight and an impossible one such as 2026-02-30 is
+    // no date; other text keeps the Date parser's reading.
+    const instant = (v: EvalValue): number =>
+      ISO_DATE_TIME.test(toString(v).trim()) ? (toDateTime(v) ?? Number.NaN) : new Date(toString(v)).getTime();
+    const t1 = instant(d1V.value);
+    const t2 = instant(d2V.value);
+    if (Number.isNaN(t1)) return err("PARSE_ERROR", `DATEDIFF: first argument is not a valid date`);
+    if (Number.isNaN(t2)) return err("PARSE_ERROR", `DATEDIFF: second argument is not a valid date`);
     let unit = "days";
     if (args.length === 3) {
       const u = state.evaluate(args[2]!);
       if (u.kind === "error") return u;
       unit = toString(u.value).toLowerCase();
     }
-    const diffMs = d2.getTime() - d1.getTime();
+    // Two dates are whole days apart, also across a daylight saving change.
+    const dayMs = 1000 * 60 * 60 * 24;
+    const wholeDays = ISO_DATE.test(toString(d1V.value).trim()) && ISO_DATE.test(toString(d2V.value).trim());
+    const diffMs = wholeDays ? Math.round((t2 - t1) / dayMs) * dayMs : t2 - t1;
     switch (unit) {
       case "ms":
       case "milliseconds":
@@ -1030,18 +1107,45 @@ const FUNCTION_NAMES = Object.keys(FUNCTIONS);
 
 // -- Binop application --------------------------------------------------------
 
+/**
+ * The two numbers the ordering operators compare, or null when the
+ * values have no common order. Two dates compare as instants and never
+ * with a number or other text, so `2026-10-12` is not `2026`. Text with
+ * a unit, such as `5 €`, compares by its leading number, as does text
+ * against text: `5 €` and `5.00 €` are neither smaller nor greater than
+ * each other, even though `==` tells their texts apart.
+ */
+const orderedPair = (l: EvalValue, r: EvalValue): [number, number] | null => {
+  const ld = toDateTime(l);
+  const rd = toDateTime(r);
+  if (ld !== null || rd !== null) return ld !== null && rd !== null ? [ld, rd] : null;
+  const ln = toNumber(l);
+  const rn = toNumber(r);
+  return ln !== null && rn !== null ? [ln, rn] : null;
+};
+
 const applyBinop = (op: BinOp, l: EvalValue, r: EvalValue): EvalResult => {
   if (op === "==" || op === "!=") {
-    // Equality: if both look numeric, compare as numbers; else as strings.
-    const ln = toNumber(l);
-    const rn = toNumber(r);
-    const equal = ln !== null && rn !== null ? ln === rn : toString(l) === toString(r);
+    const equal = isEqual(l, r);
     return ok((op === "==" ? equal : !equal) ? 1 : 0);
   }
+  if (op === "<" || op === "<=" || op === ">" || op === ">=") {
+    const pair = orderedPair(l, r);
+    if (pair === null) {
+      return toDateTime(l) !== null || toDateTime(r) !== null
+        ? err("TYPE_ERROR", `Cannot compare a date with a value that is not a date using "${op}"`)
+        : err("NON_NUMERIC", `Cannot compare non-numeric values with "${op}"`);
+    }
+    const [a, b] = pair;
+    if (op === "<") return ok(a < b ? 1 : 0);
+    if (op === "<=") return ok(a <= b ? 1 : 0);
+    if (op === ">") return ok(a > b ? 1 : 0);
+    return ok(a >= b ? 1 : 0);
+  }
   const ln = toNumber(l);
   const rn = toNumber(r);
   if (ln === null || rn === null) {
-    return err("NON_NUMERIC", `Cannot compare/compute non-numeric values with "${op}"`);
+    return err("NON_NUMERIC", `Cannot compute non-numeric values with "${op}"`);
   }
   switch (op) {
     case "+":
@@ -1053,14 +1157,6 @@ const applyBinop = (op: BinOp, l: EvalValue, r: EvalValue): EvalResult => {
     case "/":
       if (rn === 0) return err("DIV_BY_ZERO", `Division by zero`);
       return ok(ln / rn);
-    case "<":
-      return ok(ln < rn ? 1 : 0);
-    case "<=":
-      return ok(ln <= rn ? 1 : 0);
-    case ">":
-      return ok(ln > rn ? 1 : 0);
-    case ">=":
-      return ok(ln >= rn ? 1 : 0);
   }
 };
 

package/src/shared/markdown/index.ts

@@ -5,13 +5,13 @@
  * the visual appearance of the CodeMirror editor extensions.
  */
 
-import { Marked } from "marked";
+import { markdownInfoBlocks } from "@k2b/ui";
+import { Marked, type MarkedExtension } from "marked";
 import sanitizeHtml from "sanitize-html";
 import { markdownClient } from "./client";
 import { codeExtension } from "./extensions/code";
 import { guidedHelpExtension } from "./extensions/guided-help";
 import { imagesExtension } from "./extensions/images";
-import { infoBlocksExtension } from "./extensions/info-blocks";
 import { katexExtension } from "./extensions/katex";
 import { linksExtension } from "./extensions/links";
 import { markExtension } from "./extensions/mark";
@@ -23,7 +23,7 @@ import { taskListExtension } from "./extensions/task-list";
 type MarkdownProfile = "content" | "help";
 type LinkStyle = "widget" | "plain";
 
-const createMarked = (profile: MarkdownProfile = "content", links: LinkStyle = "widget") => {
+const createMarked = (profile: MarkdownProfile, links: LinkStyle, infoBlocks: MarkedExtension) => {
   const marked = new Marked();
 
   marked.use({
@@ -33,7 +33,7 @@ const createMarked = (profile: MarkdownProfile = "content", links: LinkStyle = "
 
   // Apply extensions in order
   // Note: katexExtension must come before codeExtension to handle ```math blocks
-  marked.use(infoBlocksExtension());
+  marked.use(infoBlocks);
   marked.use(taskListExtension());
   marked.use(tablesExtension());
   // Plain links keep marked's own renderer: an anchor around the link text.
@@ -49,17 +49,29 @@ const createMarked = (profile: MarkdownProfile = "content", links: LinkStyle = "
   return marked;
 };
 
-const marked = createMarked();
-const helpMarked = createMarked("help");
-const plainLinksMarked = createMarked("content", "plain");
+// One instance per UI message catalog, not per requested locale: request
+// headers choose the locale, and `markdownInfoBlocks()` returns one extension
+// for every locale that shares a catalog, so the cache stays bounded.
+const instances = new Map<MarkedExtension, Map<string, Marked>>();
+const markedFor = (profile: MarkdownProfile, links: LinkStyle = "widget", locale?: string): Marked => {
+  const infoBlocks = markdownInfoBlocks({ locale });
+  const byStyle = instances.get(infoBlocks) ?? new Map<string, Marked>();
+  instances.set(infoBlocks, byStyle);
+  const key = `${profile}:${links}`;
+  const instance = byStyle.get(key) ?? createMarked(profile, links, infoBlocks);
+  byStyle.set(key, instance);
+  return instance;
+};
+
+const marked = markedFor("content");
 
 export type MarkdownRenderOptions = {
   /** `"plain"` renders each link as an ordinary anchor around its text, for HTML read outside Cloud such as email. */
   links?: LinkStyle;
+  /** Request locale for the screen-reader names of untitled info blocks. Defaults to English on the server and the page language in the browser. */
+  locale?: string;
 };
 
-const markedFor = ({ links = "widget" }: MarkdownRenderOptions): Marked => (links === "plain" ? plainLinksMarked : marked);
-
 const sanitizeRenderedHtml = (html: string): string =>
   sanitizeHtml(html, {
     allowedTags: [
@@ -136,7 +148,8 @@ const sanitizeRenderedHtml = (html: string): string =>
  *
  * Supported features:
  * - GFM (GitHub Flavored Markdown)
- * - Notice cards (:::note, :::info, :::success, :::warning, :::danger)
+ * - Info blocks (:::note, :::info, :::success, :::warning, :::danger), shared
+ *   with `MarkdownView` from `@k2b/ui`
  * - Task lists with checkboxes
  * - Tables with cell formatting
  * - Styled links and images
@@ -160,7 +173,7 @@ const sanitizeRenderedHtml = (html: string): string =>
 export function renderMarkdown(content: string, options: MarkdownRenderOptions = {}): string {
   if (!content || typeof content !== "string") return "";
 
-  const html = markedFor(options).parse(content);
+  const html = markedFor("content", options.links, options.locale).parse(content);
   if (typeof html !== "string") return "";
 
   return sanitizeRenderedHtml(html);
@@ -172,7 +185,7 @@ export function renderMarkdown(content: string, options: MarkdownRenderOptions =
 export function renderMarkdownSync(content: string, options: MarkdownRenderOptions = {}): string {
   if (!content || typeof content !== "string") return "";
 
-  const html = markedFor(options).parse(content);
+  const html = markedFor("content", options.links, options.locale).parse(content);
   if (typeof html !== "string") return "";
 
   return sanitizeRenderedHtml(html);
@@ -182,9 +195,9 @@ export function renderMarkdownSync(content: string, options: MarkdownRenderOptio
  * Render trusted documentation Markdown with guided sections and internal
  * navigation. All fenced code remains visible source, as in ordinary Markdown.
  */
-export function renderHelpMarkdown(content: string): string {
+export function renderHelpMarkdown(content: string, locale?: string): string {
   if (!content || typeof content !== "string") return "";
-  const html = helpMarked.parse(content);
+  const html = markedFor("help", "widget", locale).parse(content);
   return typeof html === "string" ? sanitizeRenderedHtml(html) : "";
 }
 

package/src/ssr/PwaLayout.tsx

@@ -48,8 +48,9 @@ export default function PwaLayout(props: PwaLayoutProps) {
   const path = new URL(c.req.raw.url).pathname;
   const tabs = parts.slice(0, TAB_PARTS);
   const currentTab = tabs.find((part) => path === part.pwa.href || path.startsWith(`${part.pwa.href}/`));
+  // Start is titled with the installation's name; a part's first page carries the part's name.
   const items: TabBarItem[] = [
-    { id: "start", label: t.start, icon: "ti ti-home", href: PWA_SCOPE, current: !currentTab },
+    { id: "start", label: t.start, title: cloud, icon: "ti ti-home", href: PWA_SCOPE, current: !currentTab },
     ...tabs.map((part) => ({ id: part.id, label: part.name, icon: part.icon, href: part.pwa.href, current: part === currentTab })),
   ];
 

package/src/styles/resource-search.css

@@ -214,6 +214,24 @@
   color: var(--k2b-text-muted);
   font-size: 0.8125rem;
 }
+/* Apps still searching and apps that did not answer: one calm line each, below the results. */
+.cloud-resource-search__status {
+  display: grid;
+  gap: 0.125rem;
+  padding: 0 1.125rem 1.5rem;
+  color: var(--k2b-text-muted);
+  font-size: 0.8125rem;
+}
+.cloud-resource-search__status p {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.375rem;
+  min-height: 1.75rem;
+}
+.cloud-resource-search__status i {
+  font-size: 0.875rem;
+}
 .cloud-resource-search__tag-heading {
   display: flex;
   align-items: center;
@@ -386,6 +404,7 @@
     padding-inline: 0;
   }
   .cloud-resource-search__hint,
+  .cloud-resource-search__status,
   .cloud-resource-search__idle,
   .cloud-resource-search__footer,
   .cloud-resource-search__count,

package/src/ai/client/live-connection.ts

@@ -1,141 +0,0 @@
-import {
-  createLiveWebSocket,
-  type LiveWebSocket,
-  type LiveWebSocketClose,
-  type LiveWebSocketError,
-  type LiveWebSocketStatus,
-} from "../../browser/live-websocket";
-import { AI_LIVE_WS_TYPE, type AiLiveServerMessage, parseAiLiveServerMessage } from "../live-events";
-import type { AiConversationStreamTransport, AiStreamConnectionStatus } from "./transport";
-
-type TurnSubscription = {
-  conversationId: string;
-  generation: number;
-  onEvent: Parameters<AiConversationStreamTransport["subscribe"]>[0]["onEvent"];
-  onStatus?: Parameters<AiConversationStreamTransport["subscribe"]>[0]["onStatus"];
-  onError?: Parameters<AiConversationStreamTransport["subscribe"]>[0]["onError"];
-};
-
-export type AiLiveConnection = {
-  connect: () => void;
-  markApplied: (cursor: string | null | undefined) => void;
-  streamTransport: AiConversationStreamTransport;
-  dispose: () => void;
-};
-
-export type CreateAiLiveConnectionOptions = {
-  url?: string;
-  initialCursor: string;
-  onLiveMessage: (message: AiLiveServerMessage) => void;
-  onLiveStatus?: (status: LiveWebSocketStatus) => void;
-  onFatal?: (error: LiveWebSocketError) => void;
-};
-
-const reconnectableAiClose = (close: LiveWebSocketClose): LiveWebSocketError | null =>
-  close.code === 1008 ? { code: close.reason || "access_denied", message: "Live access changed or expired." } : null;
-
-const streamStatus = (status: LiveWebSocketStatus): AiStreamConnectionStatus | null => {
-  if (status === "connecting" || status === "reconnecting") return status;
-  if (status === "paused") return "reconnecting";
-  return null;
-};
-
-/** One browser connection for AI invalidations and the currently visible turn. */
-export const createAiLiveConnection = (options: CreateAiLiveConnectionOptions): AiLiveConnection => {
-  let socket: LiveWebSocket;
-  let turn: TurnSubscription | null = null;
-  let turnGeneration = 0;
-  let connected = false;
-  let disposed = false;
-  let liveSubscribeCount = 0;
-
-  const sendTurnSubscription = () => {
-    if (!connected || !turn) return;
-    if (
-      !socket.send({
-        type: AI_LIVE_WS_TYPE.turnSubscribe,
-        payload: { conversationId: turn.conversationId },
-      })
-    ) {
-      turn.onStatus?.("reconnecting");
-    }
-  };
-
-  socket = createLiveWebSocket<AiLiveServerMessage>({
-    url: options.url ?? "/api/ai/live",
-    activity: "always",
-    initialCursor: options.initialCursor,
-    subscribe: (cursor) => ({
-      type: AI_LIVE_WS_TYPE.subscribe,
-      payload: { fromCursor: cursor, recover: liveSubscribeCount++ > 0 },
-    }),
-    parse: parseAiLiveServerMessage,
-    classifyClose: reconnectableAiClose,
-    onOpen: sendTurnSubscription,
-    onStatus: (status) => {
-      connected = status === "open";
-      options.onLiveStatus?.(status);
-      const next = streamStatus(status);
-      if (next) turn?.onStatus?.(next);
-    },
-    onMessage: (message) => {
-      if (message.type === AI_LIVE_WS_TYPE.turnEvent) {
-        if (!turn || turn.conversationId !== message.payload.conversationId) return;
-        if (message.payload.event.type === "state") turn.onStatus?.("open");
-        turn.onEvent(message.payload.event);
-        return;
-      }
-      if (message.type === AI_LIVE_WS_TYPE.turnError) {
-        if (!turn || turn.conversationId !== message.payload.conversationId) return;
-        const current = turn;
-        turn = null;
-        current.onError?.(new Error(message.payload.message));
-        return;
-      }
-      options.onLiveMessage(message);
-    },
-    onFatal: (error) => {
-      connected = false;
-      const current = turn;
-      turn = null;
-      current?.onError?.(new Error(error.message));
-      options.onFatal?.(error);
-    },
-  });
-
-  const streamTransport: AiConversationStreamTransport = {
-    subscribe: ({ conversationId, onEvent, onStatus, onError }) => {
-      const generation = ++turnGeneration;
-      const subscription: TurnSubscription = { conversationId, generation, onEvent, onStatus, onError };
-      turn = subscription;
-      onStatus?.("connecting");
-      sendTurnSubscription();
-      return {
-        close: () => {
-          if (turn?.generation !== generation) return;
-          turn = null;
-          if (connected) {
-            socket.send({
-              type: AI_LIVE_WS_TYPE.turnUnsubscribe,
-              payload: { conversationId },
-            });
-          }
-        },
-      };
-    },
-  };
-
-  return {
-    connect: () => {
-      if (!disposed) socket.connect();
-    },
-    markApplied: (cursor) => socket.markApplied(cursor),
-    streamTransport,
-    dispose: () => {
-      if (disposed) return;
-      disposed = true;
-      turn = null;
-      socket.dispose();
-    },
-  };
-};

package/src/ai/live-messages.ts

@@ -1,45 +0,0 @@
-import { i18n } from "@k2b/stdlib";
-
-const catalog = i18n.define({
-  baseLocale: "en",
-  messages: {
-    en: {
-      loginRequired: "Login required",
-      conversationAccessChanged: "Conversation access changed or expired",
-      capacityExceeded: "AI updates exceeded the connection capacity",
-      authorizationRefreshFailed: "AI live authorization refresh failed",
-      invalidStreamData: "AI event stream contains invalid data",
-      eventStreamEnded: "AI event stream ended",
-      eventStreamFailed: "AI event stream failed",
-      subscriptionFailed: "AI live subscription failed",
-      conversationStreamEnded: "AI conversation stream ended",
-      conversationStreamFailed: "AI conversation stream failed",
-      liveSubscriptionRequired: "AI live subscription required before a turn subscription",
-      conversationNotFound: "Conversation not found",
-      invalidJson: "Invalid JSON payload",
-      invalidSubscription: "Invalid AI live subscription",
-      tooManyMessages: "Too many pending AI live messages",
-    },
-    de: {
-      loginRequired: "Anmeldung erforderlich",
-      conversationAccessChanged: "Der Zugriff auf die Unterhaltung wurde geändert oder ist abgelaufen",
-      capacityExceeded: "Die AI-Updates haben die Kapazität der Verbindung überschritten",
-      authorizationRefreshFailed: "Die Zugriffsprüfung für AI Live ist fehlgeschlagen",
-      invalidStreamData: "Der AI-Ereignisstrom enthält ungültige Daten",
-      eventStreamEnded: "Der AI-Ereignisstrom wurde beendet",
-      eventStreamFailed: "Der AI-Ereignisstrom ist fehlgeschlagen",
-      subscriptionFailed: "Die Anmeldung für AI Live ist fehlgeschlagen",
-      conversationStreamEnded: "Der AI-Unterhaltungsstrom wurde beendet",
-      conversationStreamFailed: "Der AI-Unterhaltungsstrom ist fehlgeschlagen",
-      liveSubscriptionRequired: "Vor dem Abonnieren eines Durchlaufs ist eine Anmeldung für AI Live erforderlich",
-      conversationNotFound: "Die Unterhaltung wurde nicht gefunden",
-      invalidJson: "Die JSON-Daten sind ungültig",
-      invalidSubscription: "Die Anmeldung für AI Live ist ungültig",
-      tooManyMessages: "Zu viele ausstehende Nachrichten für AI Live",
-    },
-  },
-});
-
-export type AiLiveMessages = ReturnType<typeof catalog.resolve>["t"];
-export const aiLiveMessages = (locale?: string | null) => catalog.resolve(locale ? [locale] : []).t;
-export const checkAiLiveMessages = () => catalog.check();

package/src/ai/live-outbox.ts

@@ -1,102 +0,0 @@
-import type { sql } from "bun";
-import { lazySync } from "../_internal/process-sync";
-import { createPgOutbox } from "../services/outbox";
-import { toPgTextArray } from "../services/postgres";
-import { latestTopicCursor } from "../services/topic-cursor";
-import type { AiInvalidation, AiInvalidationDomain } from "./live-events";
-
-const RETENTION_MS = 24 * 60 * 60 * 1_000;
-const RECONCILE_INTERVAL_MS = 1_000;
-const MAX_ATTEMPTS = 20;
-
-type SqlClient = typeof sql;
-
-export type AiLiveOutboxRow = {
-  id: string;
-  change_id: string;
-  audience_user_id: string;
-  conversation_short_id: string | null;
-  project_short_id: string | null;
-  domains: AiInvalidationDomain[];
-  attempts: number;
-  created_at: Date | string;
-};
-
-const invalidationTopic = lazySync((sync) =>
-  sync.topic<AiInvalidation>({
-    id: "cloud-ai-invalidations",
-    owner: "cloud",
-    retention: { maxAgeMs: RETENTION_MS, maxBytes: 64 * 1024 * 1024 },
-    maxPayloadBytes: 9_024,
-  }),
-);
-
-const tenantId = (userId: string): string => userId;
-
-export const enqueueAiInvalidation = async (
-  db: SqlClient,
-  input: {
-    audienceUserId: string;
-    domains: AiInvalidationDomain[];
-    conversationId?: string | null;
-    projectId?: string | null;
-    changeId?: string;
-  },
-): Promise<string> => {
-  const [row] = await db<{ id: string }[]>`
-    INSERT INTO ai.live_invalidation_outbox (
-      change_id, audience_user_id, conversation_short_id, project_short_id, domains
-    )
-    VALUES (
-      ${input.changeId ?? crypto.randomUUID()}::uuid,
-      ${input.audienceUserId}::uuid,
-      ${input.conversationId ?? null},
-      ${input.projectId ?? null},
-      ${toPgTextArray([...new Set(input.domains)])}::text[]
-    )
-    RETURNING id::text
-  `;
-  if (!row) throw new Error("AI live invalidation insert returned no id");
-  return row.id;
-};
-
-const publishAiInvalidation = (row: AiLiveOutboxRow): Promise<unknown> => {
-  const event: AiInvalidation = {
-    type: "ai.invalidated",
-    changeId: row.change_id,
-    conversationId: row.conversation_short_id,
-    projectId: row.project_short_id,
-    domains: row.domains,
-    at: new Date(row.created_at).toISOString(),
-  };
-  return invalidationTopic().publish({
-    tenantId: tenantId(row.audience_user_id),
-    orderingKey: row.conversation_short_id ?? row.project_short_id ?? row.audience_user_id,
-    idempotencyKey: row.change_id,
-    data: event,
-  });
-};
-
-const outbox = createPgOutbox<AiLiveOutboxRow>({
-  table: "ai.live_invalidation_outbox",
-  name: "ai:live-outbox",
-  publish: publishAiInvalidation,
-  reconcileIntervalMs: RECONCILE_INTERVAL_MS,
-  orderBy: "audience_user_id",
-  maxAttempts: MAX_ATTEMPTS,
-});
-
-export const claimAiInvalidationBatch = outbox.claim;
-export const dispatchAiInvalidation = outbox.dispatch;
-export const reconcileAiInvalidations = outbox.reconcile;
-export const notifyAiInvalidations = outbox.notify;
-export const startAiInvalidationRuntime = outbox.start;
-export const stopAiInvalidationRuntime = outbox.stop;
-
-export const liveAiInvalidations = (input: { userId: string; after?: string | null; signal?: AbortSignal }) =>
-  invalidationTopic()
-    .hub({ tenantId: tenantId(input.userId) })
-    .subscribe({ after: input.after ?? undefined, signal: input.signal });
-
-export const latestAiInvalidationCursor = (userId: string): Promise<string> =>
-  latestTopicCursor({ topic: invalidationTopic(), resourceId: "cloud-ai-invalidations", tenantId: tenantId(userId) });