@k2b/cloud 0.28.0 → 0.29.0

package/src/services/notifications/dispatcher.ts

@@ -2,6 +2,7 @@ import { sql } from "bun";
 import { z } from "zod";
 import { decryptSecret } from "../secrets";
 import { getNotificationChannel } from "./channels";
+import { quietStateForEvent } from "./quiet";
 
 const MAX_DELIVERY_ATTEMPTS = 5;
 const BASE_RETRY_MS = 2_000;
@@ -19,12 +20,40 @@ type DeliveryRow = {
 };
 
 export type DeliveryAttemptResult =
-  | { status: "skipped" | "delivered" | "failed" }
+  | { status: "skipped" | "delivered" | "suppressed" | "failed" }
   | { status: "pending"; retryAfterMs: number }
   | { status: "retry"; retryAfterMs: number; error: string };
 
 const retryDelay = (attempt: number): number => Math.min(BASE_RETRY_MS * 2 ** Math.max(0, attempt - 1), MAX_RETRY_MS);
 
+/**
+ * Do not disturb and quiet hours hold back recommended browser notifications when they would go out. The
+ * notification is dropped, not postponed, so nothing arrives in a burst when the quiet time ends, and it is not
+ * rerouted: the event's waiting fallbacks end with it. Required deliveries are part of a protocol and still go.
+ */
+const holdBackForQuietTime = async (delivery: DeliveryRow): Promise<boolean> => {
+  if (delivery.channel !== "browser" || delivery.required) return false;
+  const quiet = await quietStateForEvent(delivery.event_id);
+  if (!quiet?.active) return false;
+  const code = quiet.reason === "doNotDisturb" ? "do_not_disturb" : "quiet_hours";
+  const message = quiet.reason === "doNotDisturb" ? "Held back by do not disturb." : "Held back during quiet hours.";
+  // One transaction: a crash in between must not leave fallbacks waiting, with their payload, behind a dropped push.
+  await sql.begin(async (tx) => {
+    await tx`
+      UPDATE notifications.deliveries
+      SET status = 'suppressed', attempt_count = attempt_count - 1, next_attempt_at = NULL,
+          error_code = ${code}, error_message = ${message}, payload_encrypted = NULL, updated_at = now()
+      WHERE id = ${delivery.id}::uuid AND status = 'sending'
+    `;
+    await tx`
+      UPDATE notifications.deliveries
+      SET status = 'suppressed', error_code = ${code}, error_message = ${message}, payload_encrypted = NULL, updated_at = now()
+      WHERE event_id = ${delivery.event_id}::uuid AND required = false AND status = 'deferred'
+    `;
+  });
+  return true;
+};
+
 const activateNextFallback = async (eventId: string): Promise<string[]> => {
   const delivered = await sql<{ exists: boolean }[]>`
     SELECT EXISTS (
@@ -85,6 +114,7 @@ export const processNotificationDelivery = async (
   if (!delivery) return { status: "skipped" };
 
   try {
+    if (await holdBackForQuietTime(delivery)) return { status: "suppressed" };
     const driver = getNotificationChannel(delivery.channel);
     if (!driver)
       throw Object.assign(new Error(`Notification channel "${delivery.channel}" is unavailable`), { code: "channel_unavailable" });

package/src/services/notifications/platform.ts

@@ -1,5 +1,6 @@
 import { sql } from "bun";
 import type { output, ZodType } from "zod";
+import { isNotificationGroup, notificationGroupTag } from "../../contracts/notification-group";
 import type {
   BoundNotificationDefinition,
   EmailNotificationPresentation,
@@ -15,6 +16,7 @@ import { encryptSecret } from "../secrets";
 import { ensureNotificationDefinition } from "./catalog";
 import { getNotificationChannel, type NotificationDestination, type ResolvedNotificationRecipient } from "./channels";
 import { processNotificationDelivery } from "./dispatcher";
+import { normalizeNotificationPreview } from "./preview";
 import { enqueueNotificationDeliveries, enqueueNotificationDelivery } from "./runtime";
 
 export type TypedNotificationDeliveryStatus = "deferred" | "pending" | "sending" | "delivered" | "suppressed" | "failed";
@@ -69,14 +71,38 @@ const preparationFailure = (input: { channel: string; required: boolean; routePr
   errorMessage: "Notification delivery could not be prepared.",
 });
 
-const validatePresentation = (presentation: NotificationPresentation): NotificationPresentation => {
+const validatePresentation = (presentation: NotificationPresentation, appId: string): NotificationPresentation => {
   const title = presentation.title.trim();
   const body = presentation.body?.trim();
+  if (presentation.preview !== undefined && typeof presentation.preview !== "string") {
+    throw new Error("Notification preview must be a string");
+  }
+  const preview = presentation.preview === undefined ? undefined : normalizeNotificationPreview(presentation.preview);
   if (!title) throw new Error("Notification title is required");
   if (title.length > 200) throw new Error("Notification title must not exceed 200 characters");
   if (body && body.length > 4_000) throw new Error("Notification body must not exceed 4000 characters");
   const targetHref = presentation.targetHref ? validateNotificationTargetHref(presentation.targetHref) : undefined;
-  return { title, ...(body ? { body } : {}), ...(targetHref ? { targetHref } : {}) };
+  if (presentation.group !== undefined && !isNotificationGroup(presentation.group)) {
+    throw new Error(
+      "Notification group must contain 1 to 128 characters using only letters, digits, dots, underscores, colons, or hyphens",
+    );
+  }
+  if (presentation.group !== undefined && notificationGroupTag(appId, presentation.group) === null) {
+    throw new Error(
+      "Notification group requires an app ID that starts with a lowercase letter and contains only lowercase letters, digits, and hyphens",
+    );
+  }
+  if (presentation.badge !== undefined && (!Number.isSafeInteger(presentation.badge) || presentation.badge < 0)) {
+    throw new Error("Notification badge must be a non-negative safe integer");
+  }
+  return {
+    title,
+    ...(body ? { body } : {}),
+    ...(preview ? { preview } : {}),
+    ...(targetHref ? { targetHref } : {}),
+    ...(presentation.group !== undefined ? { group: presentation.group } : {}),
+    ...(presentation.badge !== undefined ? { badge: presentation.badge } : {}),
+  };
 };
 
 const resolveRecipient = async (
@@ -172,6 +198,8 @@ const prepareChannel = async (input: {
 
   try {
     const emailPresentation = input.channel === "email" ? await input.emailPresentation?.() : undefined;
+    const { preview: _preview, ...otherPresentation } = input.presentation;
+    const presentation = input.channel === "browser" ? input.presentation : otherPresentation;
     return await Promise.all(
       destinations.map(async (destination) => ({
         channel: input.channel,
@@ -179,7 +207,7 @@ const prepareChannel = async (input: {
         destinationKey: destination.key,
         destinationLabel: destination.label,
         payloadEncrypted: await encryptSecret(
-          driver.createPayload({ presentation: input.presentation, email: emailPresentation, destination, event: input.event }),
+          driver.createPayload({ presentation, email: emailPresentation, destination, event: input.event }),
         ),
         required: input.required,
         routePriority: input.routePriority,
@@ -241,7 +269,7 @@ export const sendTypedNotification = async <
 
   const data: output<S> = definition.data.parse(input.data);
   const renderContext = { locale: normalizeLocale(input.locale) };
-  const presentation = validatePresentation(await definition.render(data, renderContext));
+  const presentation = validatePresentation(await definition.render(data, renderContext), definition.appId);
   const resolved = await resolveRecipient(input.recipient);
   const candidateEventId = crypto.randomUUID();
   await ensureNotificationDefinition(definition);

package/src/services/notifications/preview.ts

@@ -0,0 +1,23 @@
+export const NOTIFICATION_PREVIEW_LIMIT = 200;
+const PREVIEW_INPUT_LIMIT = 1_000;
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export const normalizeNotificationPreview = (value: string): string | undefined => {
+  let prefix = value.slice(0, PREVIEW_INPUT_LIMIT);
+  const clipped = value.length > prefix.length;
+  if (clipped) {
+    // A boundary at or before the bound depends on at most one following code point (two UTF-16 units).
+    const last = segmenter.segment(value.slice(0, PREVIEW_INPUT_LIMIT + 2)).containing(PREVIEW_INPUT_LIMIT - 1);
+    if (last && last.index + last.segment.length > PREVIEW_INPUT_LIMIT) prefix = prefix.slice(0, last.index);
+  }
+  const text = prefix.replace(/[\s\p{Cc}]+/gu, " ").trim();
+  if (!text) return undefined;
+  if (!clipped && text.length <= NOTIFICATION_PREVIEW_LIMIT) return text;
+
+  let end = 0;
+  for (const { segment, index } of segmenter.segment(text)) {
+    if (index + segment.length > NOTIFICATION_PREVIEW_LIMIT - 1) break;
+    end = index + segment.length;
+  }
+  return `${text.slice(0, end).trimEnd()}…`;
+};

package/src/services/notifications/quiet.ts

@@ -0,0 +1,153 @@
+import { dates } from "@k2b/stdlib";
+import { sql } from "bun";
+import type { MutationResult } from "../../contracts/shared";
+import {
+  NOTIFICATION_DO_NOT_DISTURB_MAX_DAYS,
+  type NotificationQuietHours,
+  NotificationQuietHoursSchema,
+  type NotificationQuietSettings,
+  type NotificationQuietState,
+  type UpdateNotificationQuietSettings,
+} from "../../contracts/user-notifications";
+import { normalizeTimeZone } from "../../shared/time";
+
+const DAY_MS = 24 * 60 * 60_000;
+/** How far ahead `until` looks. A schedule that stays quiet for longer has no end worth naming. */
+const LOOKAHEAD_DAYS = 8;
+
+type QuietInput = { doNotDisturbUntil: Date | null; quietHours: NotificationQuietHours };
+type Interval = { start: number; end: number };
+
+const pad2 = (value: number): string => String(value).padStart(2, "0");
+
+/**
+ * The quiet-hours intervals that touch `[from - 1 day, from + days]`, as instants. Each period belongs to the
+ * local day it starts on; wall-clock times are converted per date, so a period keeps its local times across
+ * daylight-saving changes. A time inside a skipped hour moves forward like the clock does. In a repeated hour a
+ * start takes the first occurrence and an end the second, so the period covers every instant the clock shows a
+ * time inside it.
+ */
+const quietHourIntervals = (hours: NotificationQuietHours, from: number, days: number): Interval[] => {
+  if (hours.periods.length === 0) return [];
+  const timeZone = normalizeTimeZone(hours.timeZone);
+  const [localDate = ""] = dates.instantToZonedInput(new Date(from), timeZone).split("T");
+  const [year, month, day] = localDate.split("-").map(Number) as [number, number, number];
+  const instant = (offset: number, time: string, disambiguation: "compatible" | "later"): number => {
+    const date = new Date(Date.UTC(year, month - 1, day + offset));
+    const wallClock = `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())}T${time}`;
+    return Date.parse(dates.zonedDateTimeToInstant(wallClock, timeZone, { disambiguation }));
+  };
+  const intervals: Interval[] = [];
+  for (let offset = -1; offset <= days; offset += 1) {
+    const isoWeekday = new Date(Date.UTC(year, month - 1, day + offset)).getUTCDay() || 7;
+    for (const period of hours.periods) {
+      if (!period.days.includes(isoWeekday)) continue;
+      const start = instant(offset, period.start, "compatible");
+      const end = instant(period.end > period.start ? offset : offset + 1, period.end, "later");
+      if (end > start) intervals.push({ start, end });
+    }
+  }
+  return intervals;
+};
+
+/**
+ * Follow quiet hours from `from` across overlapping and adjoining periods. Returns `from` when it is not quiet
+ * and null when the quiet time does not end within the lookahead, for example with every day fully quiet.
+ */
+const quietHoursEnd = (hours: NotificationQuietHours, from: number): number | null => {
+  const intervals = quietHourIntervals(hours, from, LOOKAHEAD_DAYS);
+  const horizon = from + LOOKAHEAD_DAYS * DAY_MS;
+  let until = from;
+  for (;;) {
+    const ends = intervals.filter((interval) => interval.start <= until && until < interval.end).map((interval) => interval.end);
+    if (ends.length === 0) return until;
+    until = Math.max(...ends);
+    if (until > horizon) return null;
+  }
+};
+
+/**
+ * Whether browser notifications are held back at `now`, why, and until when. Do not disturb names the reason
+ * while it lasts; `until` also covers quiet hours that continue when it ends.
+ */
+export const notificationQuietState = (input: QuietInput, now: Date = new Date()): NotificationQuietState => {
+  const at = now.getTime();
+  const iso = (instant: number | null) => (instant === null ? null : new Date(instant).toISOString());
+  const doNotDisturbUntil = input.doNotDisturbUntil?.getTime() ?? null;
+  if (doNotDisturbUntil !== null && doNotDisturbUntil > at) {
+    return { active: true, reason: "doNotDisturb", until: iso(quietHoursEnd(input.quietHours, doNotDisturbUntil)), nextStart: null };
+  }
+  const until = quietHoursEnd(input.quietHours, at);
+  if (until !== at) return { active: true, reason: "quietHours", until: iso(until), nextStart: null };
+  const starts = quietHourIntervals(input.quietHours, at, LOOKAHEAD_DAYS)
+    .map((interval) => interval.start)
+    .filter((start) => start > at && start <= at + LOOKAHEAD_DAYS * DAY_MS);
+  return { active: false, reason: null, until: null, nextStart: iso(starts.length > 0 ? Math.min(...starts) : null) };
+};
+
+type QuietRow = { do_not_disturb_until: Date | null; time_zone: string; periods: unknown };
+
+/** Parse a stored row defensively: a schedule that no longer validates silences nothing. */
+export const quietInputFromRow = (row: QuietRow | undefined, fallbackTimeZone = "UTC"): QuietInput => {
+  const parsed = row ? NotificationQuietHoursSchema.safeParse({ timeZone: row.time_zone, periods: row.periods }) : null;
+  return {
+    doNotDisturbUntil: row?.do_not_disturb_until ?? null,
+    quietHours: parsed?.success ? parsed.data : { timeZone: normalizeTimeZone(row?.time_zone ?? fallbackTimeZone), periods: [] },
+  };
+};
+
+const toSettings = (input: QuietInput, now = new Date()): NotificationQuietSettings => ({
+  doNotDisturbUntil:
+    input.doNotDisturbUntil && input.doNotDisturbUntil.getTime() > now.getTime() ? input.doNotDisturbUntil.toISOString() : null,
+  quietHours: input.quietHours,
+  state: notificationQuietState(input, now),
+});
+
+/** The person's quiet settings and current state. Without saved quiet hours, `fallbackTimeZone` is offered. */
+const getQuietSettings = async (userId: string, fallbackTimeZone = "UTC"): Promise<NotificationQuietSettings> => {
+  const [row] = await sql<QuietRow[]>`
+    SELECT do_not_disturb_until, time_zone, periods FROM notifications.quiet_times WHERE user_id = ${userId}::uuid
+  `;
+  return toSettings(quietInputFromRow(row, fallbackTimeZone));
+};
+
+const updateQuietSettings = async (config: {
+  userId: string;
+  update: UpdateNotificationQuietSettings;
+  fallbackTimeZone?: string;
+}): Promise<MutationResult<NotificationQuietSettings>> => {
+  const { doNotDisturbUntil, quietHours } = config.update;
+  const until = doNotDisturbUntil ? new Date(doNotDisturbUntil) : null;
+  if (until && until.getTime() <= Date.now()) {
+    return { ok: false, error: "Do not disturb must end in the future", status: 400 };
+  }
+  if (until && until.getTime() > Date.now() + NOTIFICATION_DO_NOT_DISTURB_MAX_DAYS * DAY_MS) {
+    return { ok: false, error: "Do not disturb must end within a year", status: 400 };
+  }
+  const timeZone = normalizeTimeZone(quietHours?.timeZone ?? config.fallbackTimeZone);
+  const periods = quietHours ? JSON.stringify(quietHours.periods) : "[]";
+  await sql`
+    INSERT INTO notifications.quiet_times (user_id, do_not_disturb_until, time_zone, periods, updated_at)
+    VALUES (${config.userId}::uuid, ${until}::timestamptz, ${timeZone}, (${periods}::text)::jsonb, now())
+    ON CONFLICT (user_id) DO UPDATE SET
+      do_not_disturb_until = CASE WHEN ${doNotDisturbUntil !== undefined} THEN EXCLUDED.do_not_disturb_until
+        ELSE notifications.quiet_times.do_not_disturb_until END,
+      time_zone = CASE WHEN ${quietHours !== undefined} THEN EXCLUDED.time_zone ELSE notifications.quiet_times.time_zone END,
+      periods = CASE WHEN ${quietHours !== undefined} THEN EXCLUDED.periods ELSE notifications.quiet_times.periods END,
+      updated_at = now()
+  `;
+  return { ok: true, data: await getQuietSettings(config.userId, config.fallbackTimeZone) };
+};
+
+/** The quiet state of an event's recipient, or null when the recipient is not a Cloud user. */
+export const quietStateForEvent = async (eventId: string, now = new Date()): Promise<NotificationQuietState | null> => {
+  const [row] = await sql<QuietRow[]>`
+    SELECT q.do_not_disturb_until, q.time_zone, q.periods
+    FROM notifications.events e
+    JOIN notifications.quiet_times q ON q.user_id = e.recipient_user_id
+    WHERE e.id = ${eventId}::uuid
+  `;
+  return row ? notificationQuietState(quietInputFromRow(row), now) : null;
+};
+
+export const userQuietTimes = { get: getQuietSettings, update: updateQuietSettings } as const;

package/src/services/notifications/user.ts

@@ -14,6 +14,7 @@ import type {
 import { normalizeLocale } from "../../shared/locale";
 import { toPgTextArray } from "../postgres";
 import { listNotificationChannels } from "./channels";
+import { userQuietTimes } from "./quiet";
 
 type PreferenceRow = {
   id: string;
@@ -164,6 +165,10 @@ const publicDeliveryError = (code: string | null, status: NotificationDeliverySt
       return { code, message: "This delivery channel is currently unavailable." };
     case "no_endpoint":
       return { code, message: "No registered destination is available for this channel." };
+    case "do_not_disturb":
+      return { code, message: "Held back because do not disturb was on." };
+    case "quiet_hours":
+      return { code, message: "Held back during your quiet hours." };
     case "fallback_not_needed":
       return { code, message: "Another preferred channel delivered this notification." };
     case "lease_recovered":
@@ -245,4 +250,5 @@ const listHistory = async (config: {
 export const userNotifications = {
   preferences: { list: listPreferences, set: setPreference, reset: resetPreference },
   history: { list: listHistory },
+  quiet: userQuietTimes,
 } as const;

package/src/services/pdf/template-preview.ts

@@ -1,4 +1,4 @@
-import { type LiquidTemplateOptions, renderLiquidTemplate } from "../../shared/template-rendering";
+import { LiquidTemplateError, type LiquidTemplateOptions, renderLiquidTemplate } from "../../shared/template-rendering";
 import {
   type GotenbergConfig,
   GotenbergRenderError,
@@ -84,6 +84,7 @@ export const renderTemplatePdfPreview = async (
       ok: false,
       error: {
         phase: "template",
+        ...(error instanceof LiquidTemplateError ? { code: error.reason } : {}),
         message: error instanceof Error ? error.message : "Template rendering failed.",
         status: 400,
       },

package/src/services/settings/app.ts

@@ -9,6 +9,7 @@
 
 import { err, fail, ok, type PageParams, type Paginated } from "@k2b/stdlib";
 import { paginateItems } from "../../server/services";
+import { ImageMetadataError } from "../image-metadata";
 import type { SettingEntry } from ".";
 import * as settingsPrimitives from ".";
 import { SETTINGS_MAP, validateSettingValue } from "./defaults";
@@ -66,6 +67,8 @@ export const settingsService = {
         await settingsPrimitives.set(config.key, validated.value);
         return ok(undefined);
       } catch (error) {
+        // A Result cannot carry 422; the typed HTTPException keeps its status through Hono.
+        if (error instanceof ImageMetadataError) throw error;
         const message = error instanceof Error ? error.message : String(error);
         if (message.startsWith("Unknown setting:")) {
           return fail(err.badInput(message));

package/src/services/settings/store.ts

@@ -17,6 +17,7 @@ import { sql } from "bun";
 import { HTTPException } from "hono/http-exception";
 import { hasRole, type User } from "../../contracts/shared";
 import { claimCacheFill, completeCacheFill, MISSING_SETTING } from "../cache-fill";
+import { stripImageDataUrlMetadata } from "../image-metadata";
 import { toPgTextArray } from "../postgres";
 import { requestCacheRedis } from "../request-cache-redis";
 import { decryptValue, encryptValue } from "./crypto";
@@ -193,7 +194,9 @@ export const writeKey = async (key: string, value: unknown, db?: SqlClient): Pro
   const validated = validateSettingValue(def, value);
   if (!validated.ok) throw new Error(validated.error);
 
-  const encrypted = await encryptValue(validated.value);
+  const storedValue =
+    def.kind === "image" && typeof validated.value === "string" ? stripImageDataUrlMetadata(validated.value) : validated.value;
+  const encrypted = await encryptValue(storedValue);
   await (db ?? sql)`
     INSERT INTO settings.entries (key, value, updated_at)
     VALUES (${key}, ${encrypted}, now())

package/src/services/weather/geo.ts

@@ -36,7 +36,11 @@ const mapPlace = (place: GeoPlace): WeatherCity => ({
 const getGeoBaseUrl = async (): Promise<Result<string>> => {
   const geoUrl = (await settings.get<string>("weather.geo_url")).trim();
   if (!geoUrl) {
-    return fail(err.internal("Geo API URL is not configured. Set weather.geo_url."));
+    return fail({
+      code: "WEATHER_CITY_SEARCH_NOT_CONFIGURED",
+      message: "Geo API URL is not configured. Set weather.geo_url.",
+      status: 500,
+    });
   }
   return ok(geoUrl.replace(/\/$/, ""));
 };
@@ -69,7 +73,7 @@ const list = async (config: {
   }
 
   const baseUrlResult = await getGeoBaseUrl();
-  if (!baseUrlResult.ok) return unavailable();
+  if (!baseUrlResult.ok) return baseUrlResult;
   const geoUrl = baseUrlResult.data;
   const result = await geoService.place.list({
     baseUrl: geoUrl,

package/src/shared/ai-platform-prompt.ts

@@ -57,7 +57,7 @@ Most replies need no offer. Make at most one offer, in the last sentence of the
 - The user corrected a result that their own Skill shaped: offer to add the correction to that Skill.
 {%- endif %}
 {%- if memoryToolEnabled %}
-- The user corrected the tone of a result that a built-in or shared Skill shaped, such as a mail that is too formal: offer to remember it as their preference. Memory keeps only the user's own words, so a plain yes cannot be saved: suggest a one-line rule they can send back, such as "Always write mails casually and briefly".
+- The user corrected the tone of a result, such as a mail that is too formal, without stating a lasting rule: offer to remember it as their preference. Memory keeps only the user's own words, so a plain yes cannot be saved: suggest a one-line rule they can send back, such as "Always write mails casually and briefly".
 {%- endif %}
 - The user says the request recurs (again, every week, like last time, always), pastes a long reusable instruction, or a workflow default covers it: offer to save it as a {% if skillOffers %}Skill or {% endif %}scheduled task.
 - A concrete next step clearly saves the user real work they may not know you can do: offer it, such as a manual follow-up the user mentioned, drafting the reply, or turning findings into Space tasks.
@@ -66,7 +66,7 @@ Offer only what the Skills, tool hints, and apps in this prompt support. Do not
 Offer a new Skill only when no listed Skill{% if skillSearch %} or search_skills result{% endif %} already covers the approach; a single preference belongs in memory, not a Skill. Built-in and shared Skills change for everyone, so change one only when the user asks for that. After a yes to a Skill offer, load skill-creator and draft from this conversation; its create or update review is the confirmation.
 {%- endif %}
 Make no offer for a simple fact or small talk, while you ask a question or wait for approval, after a failure or blocker, when your previous reply already ended with an offer, when the user declined it in this chat, or when the user asked for no suggestions or only a short answer. A request to shorten a draft or text is a correction, not a request for no offers. Organization, Project, and user instructions about suggestions take precedence.
-When the user asks what you can do, first take one quick look, where your tools allow it, at what they already work with, such as their Spaces, recent chats, or files, and lead with that. Give three to five concrete examples grounded in that work and in the Skills, tools, and apps available to you; leave out apps where they have no data, such as mail without a mailbox.
+When the user asks what you can do, lead with what they already work with: use the Recent work section when it is present; otherwise first take one quick look, where your tools allow it, at their Spaces, recent chats, or files. Give three to five concrete examples grounded in that work and in the Skills, tools, and apps available to you; leave out apps where they have no data, such as mail without a mailbox.
 {%- endif %}
 {%- if tools.size > 0 %}
 

package/src/shared/redirect.ts

@@ -9,7 +9,8 @@ export const normalizeRedirectTo = (value: string | null | undefined): string |
 
   try {
     const url = new URL(trimmed, REDIRECT_BASE);
-    if (url.origin !== REDIRECT_BASE) return undefined;
+    // Dot segments can resolve to `//host`, which a browser reads as another host.
+    if (url.origin !== REDIRECT_BASE || url.pathname.startsWith("//")) return undefined;
     return `${url.pathname}${url.search}${url.hash}`;
   } catch {
     return undefined;

package/src/shared/template-rendering.ts

@@ -1,10 +1,24 @@
-import { Liquid } from "liquidjs";
+import {
+  AssertionError,
+  Context,
+  defaultOperators,
+  type Emitter,
+  type FilterImplOptions,
+  Liquid,
+  LiquidError,
+  type Operators,
+  toValue,
+  toValueSync,
+} from "liquidjs";
 
 const TEMPLATE_MAX_BYTES = 200_000;
 const RENDER_MAX_BYTES = 300_000;
+// Synchronous rendering blocks every request in the app process. Legitimate templates
+// take milliseconds; keep this well below normal request latency budgets.
+const RENDER_TIMEOUT_MS = 1_000;
 
 type LiquidEngine = Liquid;
-export type LiquidTemplateErrorReason = "render_too_large";
+export type LiquidTemplateErrorReason = "render_too_large" | "render_timeout" | "render_memory_limit";
 
 export class LiquidTemplateError extends Error {
   constructor(
@@ -22,6 +36,7 @@ export type LiquidTemplateOptions = {
   escapeOutput?: boolean | ((value: unknown) => string);
   templateMaxBytes?: number;
   renderMaxBytes?: number;
+  renderTimeoutMs?: number;
   memoryLimit?: number;
 };
 
@@ -52,6 +67,35 @@ const TEMPLATE_TAG_RE = /{%-?\s*([A-Za-z_][A-Za-z0-9_]*)\b/g;
 
 const byteLength = (value: string): number => new TextEncoder().encode(value).byteLength;
 
+class BoundedEmitter implements Emitter {
+  buffer = "";
+  private bytes = 0;
+  private lastCodeUnit = 0;
+
+  constructor(private readonly maxBytes: number) {}
+
+  write(input: unknown): void {
+    const value: unknown = toValue(input);
+    // Match LiquidJS's emitter: nil is empty, arrays concatenate their elements.
+    if (value === null || value === undefined) return;
+    if (Array.isArray(value)) {
+      for (const item of value) this.write(item);
+      return;
+    }
+    const chunk = String(value);
+    if (!chunk) return;
+    const last = this.lastCodeUnit;
+    const first = chunk.charCodeAt(0);
+    // A surrogate pair split across writes encodes as four bytes, rather than six.
+    const paired = last >= 0xd800 && last <= 0xdbff && first >= 0xdc00 && first <= 0xdfff;
+    const bytes = this.bytes + byteLength(chunk) - (paired ? 2 : 0);
+    if (bytes > this.maxBytes) throw new LiquidTemplateError("render_too_large", "Rendered template is too large");
+    this.bytes = bytes;
+    this.lastCodeUnit = chunk.charCodeAt(chunk.length - 1);
+    this.buffer += chunk;
+  }
+}
+
 export const escapeTemplateOutput = (value: unknown): string =>
   String(value).replace(/[&<>"'`=/]/g, (char) => {
     switch (char) {
@@ -76,16 +120,34 @@ export const escapeTemplateOutput = (value: unknown): string =>
     }
   });
 
+const expandedTextLength = (input: unknown): number => {
+  const value: unknown = toValue(input);
+  if (typeof value === "string") return value.length;
+  if (Array.isArray(value)) return value.reduce((length: number, item: unknown) => length + expandedTextLength(item), 0);
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value).length;
+  return 0;
+};
+
 const createEngine = (options: LiquidTemplateOptions = {}) => {
   const outputEscape =
     typeof options.escapeOutput === "function" ? options.escapeOutput : options.escapeOutput === false ? undefined : escapeTemplateOutput;
+  const operators: Operators = {};
+  for (const [name, handler] of Object.entries(defaultOperators)) {
+    operators[name] = (...args: [unknown, Context] | [unknown, unknown, Context]): boolean => {
+      const result: boolean = Reflect.apply(handler, undefined, args);
+      const context = args[args.length - 1];
+      if (context instanceof Context) context.renderLimit.check(performance.now());
+      return result;
+    };
+  }
   const engine = new Liquid({
+    operators,
     strictVariables: true,
     strictFilters: true,
     ownPropertyOnly: true,
     ...(outputEscape ? { outputEscape } : {}),
     parseLimit: options.templateMaxBytes ?? TEMPLATE_MAX_BYTES,
-    renderLimit: options.renderMaxBytes ?? RENDER_MAX_BYTES,
+    renderLimit: options.renderTimeoutMs ?? RENDER_TIMEOUT_MS,
     memoryLimit: options.memoryLimit ?? 2_000_000,
     cache: false,
     dynamicPartials: false,
@@ -94,7 +156,42 @@ const createEngine = (options: LiquidTemplateOptions = {}) => {
     partials: [],
   });
 
+  const renderTemplates = engine.renderer.renderTemplates.bind(engine.renderer);
+  engine.renderer.renderTemplates = function* (templates, context, emitter) {
+    // Capture renders without an emitter; bound its intermediate buffer as well.
+    const result = yield* renderTemplates(
+      templates,
+      context,
+      emitter ?? new BoundedEmitter(Math.max(options.renderMaxBytes ?? RENDER_MAX_BYTES, RENDER_MAX_BYTES)),
+    );
+    // LiquidJS checks before templates and every loop body (even an empty one).
+    // Check after them too, so a slow final filter cannot return over budget.
+    context.renderLimit.check(performance.now());
+    return result;
+  };
+
+  for (const name of ["push", "concat", "unshift", "map"]) {
+    const filter = engine.filters[name];
+    if (!filter) continue;
+    const handler = typeof filter === "function" ? filter : filter.handler;
+    const bounded: FilterImplOptions = function* (...args: [unknown, ...unknown[]]): Generator<unknown, unknown, unknown> {
+      const result: unknown = yield handler.apply(this, args);
+      // Charge added text only; charging the left array again would compound.
+      this.context.memoryLimit.use(expandedTextLength(name === "map" ? result : args[1]));
+      return result;
+    };
+    engine.registerFilter(name, typeof filter === "function" ? bounded : { ...filter, handler: bounded });
+  }
   for (const [name, filter] of Object.entries(options.filters ?? {})) engine.registerFilter(name, filter);
+  for (const [name, filter] of Object.entries(engine.filters)) {
+    const handler = typeof filter === "function" ? filter : filter.handler;
+    const timed: FilterImplOptions = function* (...args: [unknown, ...unknown[]]): Generator<unknown, unknown, unknown> {
+      const result: unknown = yield handler.apply(this, args);
+      this.context.renderLimit.check(performance.now());
+      return result;
+    };
+    engine.registerFilter(name, typeof filter === "function" ? timed : { ...filter, handler: timed });
+  }
   return engine;
 };
 
@@ -126,11 +223,27 @@ export const validateLiquidTemplate = (
 export const renderLiquidTemplate = (template: string, data: Record<string, unknown>, options: LiquidTemplateOptions = {}): string => {
   const valid = validateLiquidTemplate(template, options);
   if (!valid.ok) throw new Error(valid.error);
-  const rendered = engineFor(options).parseAndRenderSync(template, data);
-  if (byteLength(rendered) > (options.renderMaxBytes ?? RENDER_MAX_BYTES)) {
-    throw new LiquidTemplateError("render_too_large", "Rendered template is too large");
+  const engine = engineFor(options);
+  const context = new Context(data, engine.options, { sync: true }, { liquid: engine });
+  const emitter = new BoundedEmitter(options.renderMaxBytes ?? RENDER_MAX_BYTES);
+  try {
+    toValueSync(engine.renderer.renderTemplates(engine.parse(template), context, emitter));
+    return emitter.buffer;
+  } catch (error) {
+    // LiquidJS wraps emitter and limiter failures in RenderError.originalError.
+    let original = error;
+    while (original instanceof LiquidError && original.originalError) original = original.originalError;
+    if (original instanceof LiquidTemplateError) throw original;
+    if (original instanceof AssertionError) {
+      if (original.message === "template render limit exceeded") {
+        throw new LiquidTemplateError("render_timeout", "Template rendering exceeded its time budget");
+      }
+      if (original.message === "memory alloc limit exceeded") {
+        throw new LiquidTemplateError("render_memory_limit", "Template rendering exceeded its memory limit");
+      }
+    }
+    throw error;
   }
-  return rendered;
 };
 
 export const liquidTemplateVariables = (template: string, options: LiquidTemplateOptions = {}): string[] => {

package/src/ssr/AppBadge.tsx

@@ -0,0 +1,30 @@
+import { useLocale } from "@k2b/ui";
+import { Show } from "solid-js";
+import { appBadgeCount } from "./app-badges";
+import { railMessages } from "./rail-messages";
+
+/** What a screen reader hears after the app name; empty without a count. Says no more than the "99+" shown. */
+export const useAppBadgeDescription = (endpoint: () => string | undefined) => {
+  const locale = useLocale();
+  return () => {
+    const count = appBadgeCount(endpoint());
+    const t = railMessages.resolve([locale()]).t;
+    return count > 99 ? t.badgeMany : count > 0 ? t.badge({ count }) : "";
+  };
+};
+
+/**
+ * Count on the corner of an app icon. It is positioned over the icon and never
+ * takes layout space, so appearing, growing to "99+", or clearing moves
+ * nothing. Decorative: the link carries the description.
+ */
+export function AppBadge(props: { endpoint?: string }) {
+  const count = () => appBadgeCount(props.endpoint);
+  return (
+    <Show when={count() > 0}>
+      <span class="cloud-app-badge" aria-hidden="true">
+        {count() > 99 ? "99+" : count()}
+      </span>
+    </Show>
+  );
+}