@pithy-sh/support 0.5.1 → 0.6.0

package/dist/http/routes.d.ts

@@ -2,13 +2,16 @@
 // SPDX-License-Identifier: MIT
 import type { PithyHonoEnv } from "@pithy-sh/core/src/capability/capability";
 import type { Context, Hono } from "hono";
+import type { SupportStaffConfig } from "../config/config";
 import { type HandlerDeps } from "./handlers";
 /**
  * The support routes, their verification strategies, and what each accepts:
  *
  *   GET  /support/threads               → the inbox     (control-plane: support:threads:read)       query: ListThreadsQuery
+ *   GET  /support/threads/search        → search        (control-plane: support:threads:read)       query: SearchThreadsQuery
  *   GET  /support/threads/:id           → one thread    (control-plane: support:threads:read)       param: ThreadIdParam
  *   POST /support/threads/:id/archive   → done/reopen   (control-plane: support:threads:archive)    param + json
+ *   POST /support/threads/:id/assign    → who has it    (control-plane: support:threads:assign)     param + json
  *   POST /support/threads/:id/reply     → answer        (control-plane: support:threads:reply)      param + json
  *   POST /support/threads/:id/reclassify→ re-run model  (control-plane: support:threads:reclassify) param
  *   POST /support/threads/:id/flags     → read/snooze   (control-plane: support:threads:flag)       param + json
@@ -18,20 +21,26 @@ import { type HandlerDeps } from "./handlers";
  *   GET  /support/feedback              → my requests   (bearer/session)                            query: MyThreadsQuery
  *   GET  /support/feedback/:id          → one of mine   (bearer/session)                            param: ThreadIdParam
  *
- * **Two surfaces, two gates, and they never stack.** The management routes answer to a control-plane
- * credential the adopter issued, and with the seam uncomposed every one denies with
- * `controlplane/not_connected` — the correct failure for an inbox holding other people's private
+ *   POST /support/staff/threads/:id/assign → who has it (bearer/session + same-origin + staff assignPower) param + json
+ *
+ * **Three doors, three gates, and the control plane never stacks with a session.** The management routes
+ * answer to a control-plane credential the adopter issued, and with the seam uncomposed every one denies
+ * with `controlplane/not_connected` — the correct failure for an inbox holding other people's private
  * correspondence. The `feedback` routes answer to the adopter's own signed-in user, and with no auth
- * capability composed `c.var.auth` is null and every one denies. A control-plane caller holds no
- * session by design and can never satisfy `requireAuth()`; a user's session confers no scope. See
+ * capability composed `c.var.auth` is null and every one denies. The `staff` route answers to a signed-in
+ * user too, and then to `requireStaff()`: a staff power from `support({ staff })`, held in the organization
+ * the request acts for, and with no `staff` configured every caller is refused. A control-plane caller
+ * holds no session by design and can never satisfy `requireAuth()`; a user's session confers no scope —
+ * which is why staff assignment is its own route rather than a second gate on the control-plane one. See
  * `guards.ts`.
  *
- * **`requireSameOrigin()` is on the submission route and on neither read.** Cookie-mode sessions make a
- * mutating route CSRF-reachable, and this one writes into a support inbox under a real customer's name
- * — a forged submission is somebody else's words attributed to them, in the one place an operator
- * treats attribution as proven. The reads are GETs and carry no such risk. A bearer caller is
- * CSRF-exempt, and that exemption belongs to the gate `@pithy-sh/auth` publishes rather than to
- * anything decided here.
+ * **`requireSameOrigin()` is on the two session routes that write, and on no read.** Cookie-mode sessions
+ * make a mutating route CSRF-reachable. The submission route writes into a support inbox under a real
+ * customer's name — a forged submission is somebody else's words attributed to them, in the one place an
+ * operator treats attribution as proven — and the staff assign route hands a customer's conversation to
+ * somebody on a staff member's say-so. The reads are GETs and carry no such risk. A bearer caller is
+ * CSRF-exempt, and that exemption belongs to the gate `@pithy-sh/auth` publishes rather than to anything
+ * decided here.
  *
  * **Every response has an exported schema**, in `responses.ts`. Each handler's return type is
  * `z.output` of its envelope, so `c.json(await handler(...))` carries the contract without a cast — and
@@ -108,6 +117,11 @@ export interface SupportRoutesOptions {
     submission?: boolean;
     /** Resolve handler deps from the request context. */
     resolveDeps: (c: Context<PithyHonoEnv>) => Promise<HandlerDeps>;
+    /**
+     * Who of the app's signed-in users works the inbox. Absent, the staff route is still mounted and refuses
+     * every caller with 403 — it is not a feature this deployment lacks, it is a door nobody holds a key to.
+     */
+    staff?: SupportStaffConfig;
 }
 /** Register the support sub-router. Returned as the capability's `routes` hook. */
 export declare function registerSupportRoutes(options: SupportRoutesOptions): (app: Hono<PithyHonoEnv>) => void;

package/dist/http/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/http/routes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAM7E,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE1C,OAAO,EAEL,KAAK,WAAW,EAUjB,MAAM,YAAY,CAAC;AA+BpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AAEH,2CAA2C;AAC3C,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,qDAAqD;IACrD,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACjE;AAuCD,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,IAAI,CAoJtG"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/http/routes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAM7E,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,EAGL,KAAK,WAAW,EAWjB,MAAM,YAAY,CAAC;AAoCpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AAEH,2CAA2C;AAC3C,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,qDAAqD;IACrD,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAChE;;;OAGG;IACH,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAuCD,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,IAAI,CAqNtG"}

package/dist/http/routes.js

@@ -1,10 +1,10 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
-import { requireAuth } from "./guards.js";
-import { archiveConversation, listInbox, listMyThreads, listReplies, readConversation, readMyThread, reclassifyConversation, replyToConversation, submitFeedbackRequest, updateFlags } from "./handlers.js";
-import { SupportArchiveResponse, SupportFlagsResponse, SupportMyThreadResponse, SupportMyThreadsResponse, SupportReclassifiedResponse, SupportRepliesResponse, SupportReplySentResponse, SupportSubmissionResponse, SupportThreadResponse, SupportThreadsResponse } from "./responses.js";
-import { ArchiveThreadInput, FlagsInput, ListThreadsQuery, MyThreadsQuery, RepliesQuery, ReplyInput, SubmitFeedbackInput, ThreadIdParam } from "./schemas.js";
-import { SUPPORT_THREADS_ARCHIVE_SCOPE, SUPPORT_THREADS_FLAG_SCOPE, SUPPORT_THREADS_READ_SCOPE, SUPPORT_THREADS_RECLASSIFY_SCOPE, SUPPORT_THREADS_REPLY_SCOPE } from "./scopes.js";
+import { requireAuth, requireStaff } from "./guards.js";
+import { archiveConversation, assignConversation, listInbox, listMyThreads, listReplies, readConversation, readMyThread, reclassifyConversation, replyToConversation, searchInbox, submitFeedbackRequest, updateFlags } from "./handlers.js";
+import { SupportArchiveResponse, SupportAssignResponse, SupportFlagsResponse, SupportMyThreadResponse, SupportMyThreadsResponse, SupportReclassifiedResponse, SupportRepliesResponse, SupportReplySentResponse, SupportSearchResponse, SupportSubmissionResponse, SupportThreadResponse, SupportThreadsResponse } from "./responses.js";
+import { ArchiveThreadInput, AssignThreadInput, FlagsInput, ListThreadsQuery, MyThreadsQuery, RepliesQuery, ReplyInput, SearchThreadsQuery, SubmitFeedbackInput, ThreadIdParam } from "./schemas.js";
+import { SUPPORT_THREADS_ARCHIVE_SCOPE, SUPPORT_THREADS_ASSIGN_SCOPE, SUPPORT_THREADS_FLAG_SCOPE, SUPPORT_THREADS_READ_SCOPE, SUPPORT_THREADS_RECLASSIFY_SCOPE, SUPPORT_THREADS_REPLY_SCOPE } from "./scopes.js";
 import { InternalError } from "@pithy-sh/core/src/error/pithyError";
 import { requireControlPlane } from "@pithy-sh/core/src/controlPlane/http/guard";
 import { describeRoute } from "@pithy-sh/core/src/http/routeSpec";
@@ -54,6 +54,12 @@ function registerSupportRoutes(options) {
 			scopes: [SUPPORT_THREADS_READ_SCOPE],
 			responses: { 200: SupportThreadsResponse }
 		}), requireControlPlane(SUPPORT_THREADS_READ_SCOPE), validate("query", ListThreadsQuery), async (c) => c.json(await listInbox(await resolve(c), c.req.valid("query"), viewer(c))));
+		app.get(`${base}/threads/search`, describeRoute({
+			summary: "Search the inbox, by words and by meaning, ranked as one.",
+			verification: "control-plane",
+			scopes: [SUPPORT_THREADS_READ_SCOPE],
+			responses: { 200: SupportSearchResponse }
+		}), requireControlPlane(SUPPORT_THREADS_READ_SCOPE), validate("query", SearchThreadsQuery), async (c) => c.json(await searchInbox(await resolve(c), c.req.valid("query"), viewer(c))));
 		app.get(`${base}/replies`, describeRoute({
 			summary: "List the canned replies.",
 			verification: "control-plane",
@@ -72,6 +78,23 @@ function registerSupportRoutes(options) {
 			scopes: [SUPPORT_THREADS_ARCHIVE_SCOPE],
 			responses: { 200: SupportArchiveResponse }
 		}), requireControlPlane(SUPPORT_THREADS_ARCHIVE_SCOPE), validate("param", ThreadIdParam), validate("json", ArchiveThreadInput), async (c) => c.json(await archiveConversation(await resolve(c), c.req.valid("param").id, c.req.valid("json"), viewer(c))));
+		app.post(`${base}/threads/:id/assign`, describeRoute({
+			summary: "Assign a conversation to somebody, or to nobody.",
+			verification: "control-plane",
+			scopes: [SUPPORT_THREADS_ASSIGN_SCOPE],
+			responses: { 200: SupportAssignResponse }
+		}), requireControlPlane(SUPPORT_THREADS_ASSIGN_SCOPE), validate("param", ThreadIdParam), validate("json", AssignThreadInput), async (c) => c.json(await assignConversation(await resolve(c), c.req.valid("param").id, c.req.valid("json"), {
+			type: "control-plane",
+			id: viewer(c)
+		})));
+		app.post(`${base}/staff/threads/:id/assign`, describeRoute({
+			summary: "Assign a conversation as a signed-in member of the support staff.",
+			verification: ["bearer", "session"],
+			responses: { 200: SupportAssignResponse }
+		}), requireAuth(), requireSameOrigin(), requireStaff(options.staff, "assignPower"), validate("param", ThreadIdParam), validate("json", AssignThreadInput), async (c) => c.json(await assignConversation(await resolve(c), c.req.valid("param").id, c.req.valid("json"), {
+			type: "user",
+			id: submitter(c)
+		})));
 		app.post(`${base}/threads/:id/reply`, describeRoute({
 			summary: "Answer the customer.",
 			verification: "control-plane",
@@ -93,16 +116,22 @@ function registerSupportRoutes(options) {
 		if (!submission) return;
 		app.post(`${base}/feedback`, describeRoute({
 			summary: "Write in to support from the app.",
+			operation: "feedback.write",
+			tool: { effect: "sends" },
 			verification: ["bearer", "session"],
 			responses: { 201: SupportSubmissionResponse }
 		}), requireAuth(), requireSameOrigin(), validate("json", SubmitFeedbackInput), async (c) => c.json(await submitFeedbackRequest(await resolve(c), c.req.valid("json"), submitter(c)), 201));
 		app.get(`${base}/feedback`, describeRoute({
 			summary: "List the caller's own support requests.",
+			operation: "feedback.list",
+			tool: true,
 			verification: ["bearer", "session"],
 			responses: { 200: SupportMyThreadsResponse }
 		}), requireAuth(), validate("query", MyThreadsQuery), async (c) => c.json(await listMyThreads(await resolve(c), c.req.valid("query"), submitter(c))));
 		app.get(`${base}/feedback/:id`, describeRoute({
 			summary: "Read one of the caller's own support requests.",
+			operation: "feedback.read",
+			tool: true,
 			verification: ["bearer", "session"],
 			responses: { 200: SupportMyThreadResponse }
 		}), requireAuth(), validate("param", ThreadIdParam), async (c) => c.json(await readMyThread(await resolve(c), c.req.valid("param").id, submitter(c))));

package/dist/http/schemas.d.ts

@@ -18,7 +18,13 @@ export declare const ThreadIdParam: z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>;
 export type ThreadIdParam = z.infer<typeof ThreadIdParam>;
-/** The inbox listing query. */
+/**
+ * The inbox listing query.
+ *
+ * **Strict, and there is no `q`.** Listing lists; `GET {basePath}/threads/search` searches. An unknown
+ * key is refused as `validation/invalid_input` rather than ignored, so a client sending `q` is told so
+ * instead of getting the unfiltered inbox back as though it were the answer.
+ */
 export declare const ListThreadsQuery: z.ZodObject<{
     archived: z.ZodOptional<z.ZodEnum<{
         false: "false";
@@ -42,16 +48,74 @@ export declare const ListThreadsQuery: z.ZodObject<{
         email: "email";
     }>>;
     inbox: z.ZodOptional<z.ZodString>;
-    q: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodString]>>;
     cursor: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type ListThreadsQuery = z.infer<typeof ListThreadsQuery>;
+/** How a search runs. */
+export declare const SupportSearchMode: z.ZodEnum<{
+    hybrid: "hybrid";
+    keyword: "keyword";
+    semantic: "semantic";
+}>;
+export type SupportSearchMode = z.infer<typeof SupportSearchMode>;
+/** The search query. */
+export declare const SearchThreadsQuery: z.ZodObject<{
+    archived: z.ZodOptional<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>>;
+    category: z.ZodOptional<z.ZodString>;
+    declaredCategory: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        normal: "normal";
+        urgent: "urgent";
+    }>>;
+    sentiment: z.ZodOptional<z.ZodEnum<{
+        angry: "angry";
+        frustrated: "frustrated";
+        neutral: "neutral";
+        positive: "positive";
+    }>>;
+    channel: z.ZodOptional<z.ZodEnum<{
+        app: "app";
+        email: "email";
+    }>>;
+    inbox: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodString]>>;
+    q: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        hybrid: "hybrid";
+        keyword: "keyword";
+        semantic: "semantic";
+    }>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type SearchThreadsQuery = z.infer<typeof SearchThreadsQuery>;
 /** The archive/unarchive body. */
 export declare const ArchiveThreadInput: z.ZodObject<{
     archived: z.ZodBoolean;
 }, z.core.$strip>;
 export type ArchiveThreadInput = z.infer<typeof ArchiveThreadInput>;
+/** Who a thread is assigned to. */
+export declare const AssigneeInput: z.ZodObject<{
+    ref: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type AssigneeInput = z.infer<typeof AssigneeInput>;
+/** The longest assignment note, in UTF-16 code units. */
+export declare const MAX_ASSIGNMENT_NOTE_CHARS = 500;
+/** The assign/unassign body, the same on the control-plane route and the staff session route. */
+export declare const AssignThreadInput: z.ZodObject<{
+    assignee: z.ZodNullable<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AssignThreadInput = z.infer<typeof AssignThreadInput>;
 /** The reply body. */
 export declare const ReplyInput: z.ZodObject<{
     body: z.ZodString;

package/dist/http/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/http/schemas.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;;;;;;;GAWG;AAEH,+BAA+B;AAC/B,eAAO,MAAM,aAAa;;iBAOsC,CAAC;AACjE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAY1D,+BAA+B;AAC/B,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC8D,CAAC;AAC5F,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,kCAAkC;AAClC,eAAO,MAAM,kBAAkB;;iBAQuB,CAAC;AACvD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,sBAAsB;AACtB,eAAO,MAAM,UAAU;;;iBAgB0B,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD,iCAAiC;AACjC,eAAO,MAAM,UAAU;;;iBAWmC,CAAC;AAC3D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;iBA4B8D,CAAC;AACpG,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;iBAiCqF,CAAC;AACtH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,uCAAuC;AACvC,eAAO,MAAM,cAAc;;;iBAiBxB,CAAC;AACJ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,sCAAsC;AACtC,eAAO,MAAM,YAAY;;iBAM4B,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/http/schemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB;;;;;;;;;;;GAWG;AAEH,+BAA+B;AAC/B,eAAO,MAAM,aAAa;;iBAOsC,CAAC;AACjE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAyC1D;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBmE,CAAC;AACjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,yBAAyB;AACzB,eAAO,MAAM,iBAAiB;;;;EAI3B,CAAC;AACJ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,wBAAwB;AACxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBqF,CAAC;AACrH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,kCAAkC;AAClC,eAAO,MAAM,kBAAkB;;iBAQuB,CAAC;AACvD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,mCAAmC;AACnC,eAAO,MAAM,aAAa;;;iBAOoE,CAAC;AAC/F,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,yDAAyD;AACzD,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,iGAAiG;AACjG,eAAO,MAAM,iBAAiB;;;;;;iBAeiC,CAAC;AAChE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,sBAAsB;AACtB,eAAO,MAAM,UAAU;;;iBAgB0B,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD,iCAAiC;AACjC,eAAO,MAAM,UAAU;;;iBAWmC,CAAC;AAC3D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;iBA4B8D,CAAC;AACpG,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;iBAiCqF,CAAC;AACtH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,uCAAuC;AACvC,eAAO,MAAM,cAAc;;;iBAiBxB,CAAC;AACJ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,sCAAsC;AACtC,eAAO,MAAM,YAAY;;iBAM4B,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/http/schemas.js

@@ -2,10 +2,14 @@
 // SPDX-License-Identifier: MIT
 import { MAX_SUBMISSION_BODY_CHARS } from "../config/config.js";
 import { SupportChannel, SupportPriority, SupportSentiment } from "../data/enums.js";
+import { UNASSIGNED } from "../data/assignment.js";
 import { SupportSubmissionContext } from "../data/message.js";
 import "../store/paging.js";
 import { z } from "zod";
+import { PresenceParticipantName, PresenceParticipantRef } from "@pithy-sh/core/src/presence/frames";
 //#region src/http/schemas.ts
+/** An assignee reference, as the listing filters on it and an assignment names it. */
+const AssigneeRef = PresenceParticipantRef.refine((ref) => ref !== UNASSIGNED, { message: `"${UNASSIGNED}" is reserved: it is the filter for threads nobody has` }).describe("Who the thread is assigned to: an opaque reference, the participant shape presence rooms use. A management client's own reference, which it chose; or a user of the app's id. Never `none`, which is the listing's filter for threads nobody has.");
 /**
 * The request contracts every support route declares (CLAUDE.md §HTTP).
 *
@@ -22,8 +26,8 @@ import { z } from "zod";
 const ThreadIdParam = z.object({ id: z.string().uuid().describe("The thread's UUID. A param schema constrains the string; the handler still does the lookup.") }).describe("The path parameters of every single-thread route.");
 /** A category key as a filter — bounded and shaped, never resolved against the configured set. */
 const CategoryFilter = z.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/).describe("One category key from this project's effective taxonomy. A key an adopter removed simply matches nothing.");
-/** The inbox listing query. */
-const ListThreadsQuery = z.object({
+/** The filters the inbox listing and the search route share, applied in D1 either way. */
+const threadFilterFields = {
 	archived: z.enum(["true", "false"]).optional().describe("`true` for the done pile, `false` or absent for the open inbox — which is the default on purpose."),
 	category: CategoryFilter.optional().describe("Filter to one category — what the classifier made of it."),
 	declaredCategory: CategoryFilter.optional().describe("Filter to one category **the submitter chose**, which is a different question from `category` and answers it about different threads. Combining the two is how an operator finds the disagreements; asking for this one alone is how they triage a project with `ai.enabled: false`, where nothing ever writes the other."),
@@ -31,12 +35,47 @@ const ListThreadsQuery = z.object({
 	sentiment: SupportSentiment.optional().describe("Filter to one sentiment."),
 	channel: SupportChannel.optional().describe("Filter to one channel — `email` for mail, `app` for what signed-in users filed from inside the app. Absent shows both, which is the right default for an inbox that is one queue however things arrived."),
 	inbox: z.string().min(3).max(256).optional().describe("Filter to one configured inbox address, for a Worker serving several."),
-	q: z.string().min(1).max(200).optional().describe("Free text over subjects and bodies. Keyword search — the words people actually remember."),
+	assignee: z.union([z.literal(UNASSIGNED), AssigneeRef]).optional().describe("Filter to the threads one assignee has, by their `assigneeRef`, or `none` for the threads nobody has. Absent shows every thread, assigned or not.")
+};
+/**
+* The inbox listing query.
+*
+* **Strict, and there is no `q`.** Listing lists; `GET {basePath}/threads/search` searches. An unknown
+* key is refused as `validation/invalid_input` rather than ignored, so a client sending `q` is told so
+* instead of getting the unfiltered inbox back as though it were the answer.
+*/
+const ListThreadsQuery = z.object({
+	...threadFilterFields,
 	cursor: z.string().max(512).optional().describe("Where to resume, from the previous page's `nextCursor`. Opaque; a malformed one is a first page."),
 	limit: z.coerce.number().int().min(1).max(100).optional().describe("How many threads to return. Bounded, because a verified client can still have a bug.")
-}).describe("The inbox query: what to filter by, what to search for, and where to resume.");
+}).strict().describe("The inbox query: what to filter by, and where to resume. Search is its own route.");
+/** How a search runs. */
+const SupportSearchMode = z.enum([
+	"keyword",
+	"semantic",
+	"hybrid"
+]).describe("`keyword` finds the exact words — FTS5 when `search.fts` is on, the `LIKE` scan otherwise. `semantic` finds the meaning, through the message index. `hybrid` runs both and ranks them as one.");
+/** The search query. */
+const SearchThreadsQuery = z.object({
+	q: z.string().trim().min(1).max(200).describe("What to search for, in the customer's words or yours. An order number, an error, or a description."),
+	mode: SupportSearchMode.optional().describe("Which backends to run. Absent runs every one that is on, as `hybrid`. `semantic` or `hybrid` while `search.semantic` is off is refused, naming the flag."),
+	limit: z.coerce.number().int().min(1).max(50).optional().describe(`How many threads to return, best first. Default 20, at most 50. No cursor: a ranked list has a top, not pages.`),
+	...threadFilterFields
+}).strict().describe("A search over the inbox: the words, the mode, how many, and the same filters the inbox listing takes.");
 /** The archive/unarchive body. */
 const ArchiveThreadInput = z.object({ archived: z.boolean().describe("`true` marks the conversation done; `false` reopens it. Explicit rather than a toggle, so a retried request lands on the state the caller meant rather than flipping it back.") }).describe("Mark a conversation done, or reopen it.");
+/** Who a thread is assigned to. */
+const AssigneeInput = z.object({
+	ref: AssigneeRef,
+	name: PresenceParticipantName.describe("How the assignee is shown in the inbox and in the history. A label, never an identity — `ref` is that.")
+}).describe("Somebody a thread may be assigned to: an opaque reference and the name to show.");
+/** The longest assignment note, in UTF-16 code units. */
+const MAX_ASSIGNMENT_NOTE_CHARS = 500;
+/** The assign/unassign body, the same on the control-plane route and the staff session route. */
+const AssignThreadInput = z.object({
+	assignee: AssigneeInput.nullable().describe("Who should have this conversation, or `null` to unassign it. Assigning the current assignee again changes nothing and records nothing."),
+	note: z.string().trim().min(1).max(500).optional().describe("Why, in your own words. Kept in the thread's assignment history and on the audit event, and shown to anybody who can read the thread — so it is a note to colleagues, never a place for the customer's details.")
+}).describe("Assign a conversation to somebody, or to nobody.");
 /** The reply body. */
 const ReplyInput = z.object({
 	body: z.string().min(1).max(5e4).describe("The reply text, as a human wrote and edited it. Rendered HTML-escaped into the adopter's email shell — it is prose, never markup."),
@@ -88,4 +127,4 @@ const MyThreadsQuery = z.object({
 /** The canned-reply catalog query. */
 const RepliesQuery = z.object({ category: CategoryFilter.optional().describe("Order the catalog for this category — its snippets first, then the general-purpose ones. Ordering, never filtering: a misclassified thread must not hide the snippet its operator actually needs.") }).describe("How to order the canned reply catalog.");
 //#endregion
-export { ArchiveThreadInput, FlagsInput, ListThreadsQuery, MyThreadsQuery, RepliesQuery, ReplyInput, SubmitFeedbackInput, SubmittedAttachmentInput, ThreadIdParam };
+export { ArchiveThreadInput, AssignThreadInput, AssigneeInput, FlagsInput, ListThreadsQuery, MAX_ASSIGNMENT_NOTE_CHARS, MyThreadsQuery, RepliesQuery, ReplyInput, SearchThreadsQuery, SubmitFeedbackInput, SubmittedAttachmentInput, SupportSearchMode, ThreadIdParam };

package/dist/http/scopes.d.ts

@@ -1,11 +1,11 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
-import type { AdminRoute } from "@pithy-sh/core/src/controlPlane/discovery/adminRoute";
+import type { AdminRouteDeclaration } from "@pithy-sh/core/src/controlPlane/discovery/adminRoute";
 import type { ControlPlaneScope } from "@pithy-sh/core/src/controlPlane/scope/scope";
 /**
  * Support's control-plane scopes, and the admin surface a manifest advertises.
  *
- * **Separate from `guards.ts` because a scope name is a client's business** (#315). A management
+ * **Separate from `guards.ts` because a scope name is a client's business**. A management
  * client reads these to render what a connection may do, and `pithy-sh/dashboard`'s scope builder
  * writes the `pithy dashboard connect --scope …` command from exactly these constants — in a browser
  * program, with the DOM lib and no Workers types. While they sat beside the Hono middleware, naming
@@ -13,7 +13,7 @@ import type { ControlPlaneScope } from "@pithy-sh/core/src/controlPlane/scope/sc
  * program has none of. **This module imports types and nothing else, and a gate holds it there**:
  * `tooling/browser-scopes` compiles a DOM-only program against every scope the kit declares.
  *
- * ## Five scopes, because these are five different blast radii
+ * ## Six scopes, because these are six different blast radii
  *
  * The temptation is one `support:admin` flag. It is wrong on the merits, the same way payments'
  * single flag was: **reading** an inbox exposes every customer's private correspondence, while
@@ -30,7 +30,7 @@ export declare const SUPPORT_THREADS_READ_SCOPE: ControlPlaneScope;
 /** Mark a thread done or reopen it — the one shared piece of state in the model. */
 export declare const SUPPORT_THREADS_ARCHIVE_SCOPE: ControlPlaneScope;
 /**
- * Send mail to a customer under the adopter's domain. The most dangerous of the five and the reason
+ * Send mail to a customer under the adopter's domain. The most dangerous of the six and the reason
  * a single admin flag was never an option.
  */
 export declare const SUPPORT_THREADS_REPLY_SCOPE: ControlPlaneScope;
@@ -38,6 +38,11 @@ export declare const SUPPORT_THREADS_REPLY_SCOPE: ControlPlaneScope;
 export declare const SUPPORT_THREADS_RECLASSIFY_SCOPE: ControlPlaneScope;
 /** Set a viewer's own read/snooze flags. Private, uncoordinated, and the least dangerous thing here. */
 export declare const SUPPORT_THREADS_FLAG_SCOPE: ControlPlaneScope;
+/**
+ * Say who has a thread, or that nobody does. Shared state like archive, and its own scope like
+ * archive, because deciding who answers a customer is not the same permission as marking them done.
+ */
+export declare const SUPPORT_THREADS_ASSIGN_SCOPE: ControlPlaneScope;
 /**
  * Every control-plane scope support defines — what `pithy dashboard connect` offers for this
  * capability, and the list a manifest or a doc quotes rather than re-typing.
@@ -54,5 +59,5 @@ export declare const SUPPORT_CONTROL_PLANE_SCOPES: readonly ControlPlaneScope[];
  * The summaries say what the operation is *for*. A client renders these next to a button somebody is
  * about to press on a real customer's conversation.
  */
-export declare function supportAdminRoutes(basePath: string): AdminRoute[];
+export declare function supportAdminRoutes(basePath: string): AdminRouteDeclaration[];
 //# sourceMappingURL=scopes.d.ts.map

package/dist/http/scopes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../../src/http/scopes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sDAAsD,CAAC;AACvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,iGAAiG;AACjG,eAAO,MAAM,0BAA0B,EAAE,iBAA0C,CAAC;AAEpF,oFAAoF;AACpF,eAAO,MAAM,6BAA6B,EAAE,iBAA6C,CAAC;AAE1F;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,iBAA2C,CAAC;AAEtF,8EAA8E;AAC9E,eAAO,MAAM,gCAAgC,EAAE,iBAAgD,CAAC;AAEhG,wGAAwG;AACxG,eAAO,MAAM,0BAA0B,EAAE,iBAA0C,CAAC;AAEpF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,iBAAiB,EAMpE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CA6CjE"}
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../../src/http/scopes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAClG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,iGAAiG;AACjG,eAAO,MAAM,0BAA0B,EAAE,iBAA0C,CAAC;AAEpF,oFAAoF;AACpF,eAAO,MAAM,6BAA6B,EAAE,iBAA6C,CAAC;AAE1F;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,iBAA2C,CAAC;AAEtF,8EAA8E;AAC9E,eAAO,MAAM,gCAAgC,EAAE,iBAAgD,CAAC;AAEhG,wGAAwG;AACxG,eAAO,MAAM,0BAA0B,EAAE,iBAA0C,CAAC;AAEpF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,iBAA4C,CAAC;AAExF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,iBAAiB,EAOpE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,qBAAqB,EAAE,CA2E5E"}

package/dist/http/scopes.js

@@ -4,7 +4,7 @@
 /**
 * Support's control-plane scopes, and the admin surface a manifest advertises.
 *
-* **Separate from `guards.ts` because a scope name is a client's business** (#315). A management
+* **Separate from `guards.ts` because a scope name is a client's business**. A management
 * client reads these to render what a connection may do, and `pithy-sh/dashboard`'s scope builder
 * writes the `pithy dashboard connect --scope …` command from exactly these constants — in a browser
 * program, with the DOM lib and no Workers types. While they sat beside the Hono middleware, naming
@@ -12,7 +12,7 @@
 * program has none of. **This module imports types and nothing else, and a gate holds it there**:
 * `tooling/browser-scopes` compiles a DOM-only program against every scope the kit declares.
 *
-* ## Five scopes, because these are five different blast radii
+* ## Six scopes, because these are six different blast radii
 *
 * The temptation is one `support:admin` flag. It is wrong on the merits, the same way payments'
 * single flag was: **reading** an inbox exposes every customer's private correspondence, while
@@ -29,7 +29,7 @@ const SUPPORT_THREADS_READ_SCOPE = "support:threads:read";
 /** Mark a thread done or reopen it — the one shared piece of state in the model. */
 const SUPPORT_THREADS_ARCHIVE_SCOPE = "support:threads:archive";
 /**
-* Send mail to a customer under the adopter's domain. The most dangerous of the five and the reason
+* Send mail to a customer under the adopter's domain. The most dangerous of the six and the reason
 * a single admin flag was never an option.
 */
 const SUPPORT_THREADS_REPLY_SCOPE = "support:threads:reply";
@@ -38,6 +38,11 @@ const SUPPORT_THREADS_RECLASSIFY_SCOPE = "support:threads:reclassify";
 /** Set a viewer's own read/snooze flags. Private, uncoordinated, and the least dangerous thing here. */
 const SUPPORT_THREADS_FLAG_SCOPE = "support:threads:flag";
 /**
+* Say who has a thread, or that nobody does. Shared state like archive, and its own scope like
+* archive, because deciding who answers a customer is not the same permission as marking them done.
+*/
+const SUPPORT_THREADS_ASSIGN_SCOPE = "support:threads:assign";
+/**
 * Every control-plane scope support defines — what `pithy dashboard connect` offers for this
 * capability, and the list a manifest or a doc quotes rather than re-typing.
 */
@@ -46,7 +51,8 @@ const SUPPORT_CONTROL_PLANE_SCOPES = [
 	SUPPORT_THREADS_ARCHIVE_SCOPE,
 	SUPPORT_THREADS_REPLY_SCOPE,
 	SUPPORT_THREADS_RECLASSIFY_SCOPE,
-	SUPPORT_THREADS_FLAG_SCOPE
+	SUPPORT_THREADS_FLAG_SCOPE,
+	SUPPORT_THREADS_ASSIGN_SCOPE
 ];
 /**
 * Support's management surface, as `GET /control-plane/manifest` reports it.
@@ -63,47 +69,77 @@ function supportAdminRoutes(basePath) {
 	return [
 		{
 			method: "GET",
+			operation: "threads.list",
 			path: `${basePath}/threads`,
 			scope: SUPPORT_THREADS_READ_SCOPE,
-			summary: "List the inbox, newest first, filtered by category, priority, and archived, searched by text."
+			kind: "reads",
+			summary: "List the inbox, newest first, filtered by category, priority, assignee, and archived."
 		},
 		{
 			method: "GET",
+			operation: "threads.search",
+			path: `${basePath}/threads/search`,
+			scope: SUPPORT_THREADS_READ_SCOPE,
+			kind: "reads",
+			summary: "Search the inbox by words and by meaning, ranked as one, with the same filters as the list."
+		},
+		{
+			method: "GET",
+			operation: "threads.read",
 			path: `${basePath}/threads/:id`,
 			scope: SUPPORT_THREADS_READ_SCOPE,
+			kind: "reads",
 			summary: "Read one conversation, with the sender's linked account and what they bought."
 		},
 		{
 			method: "POST",
+			operation: "threads.archive",
 			path: `${basePath}/threads/:id/archive`,
 			scope: SUPPORT_THREADS_ARCHIVE_SCOPE,
+			kind: "writes",
 			summary: "Mark a conversation done, or reopen one."
 		},
 		{
 			method: "POST",
+			operation: "threads.assign",
+			path: `${basePath}/threads/:id/assign`,
+			scope: SUPPORT_THREADS_ASSIGN_SCOPE,
+			kind: "writes",
+			summary: "Give a conversation to somebody, hand it on, or give it up."
+		},
+		{
+			method: "POST",
+			operation: "threads.reply",
 			path: `${basePath}/threads/:id/reply`,
 			scope: SUPPORT_THREADS_REPLY_SCOPE,
+			kind: "sends",
 			summary: "Answer the customer, threaded so their mail client keeps one conversation."
 		},
 		{
 			method: "POST",
+			operation: "threads.reclassify",
 			path: `${basePath}/threads/:id/reclassify`,
 			scope: SUPPORT_THREADS_RECLASSIFY_SCOPE,
+			kind: "writes",
 			summary: "Re-run the classifier over this conversation's latest inbound message."
 		},
 		{
 			method: "POST",
+			operation: "threads.flags",
 			path: `${basePath}/threads/:id/flags`,
 			scope: SUPPORT_THREADS_FLAG_SCOPE,
+			kind: "writes",
 			summary: "Set your own read and snooze state for a conversation. Private to you."
 		},
 		{
 			method: "GET",
+			operation: "replies.list",
 			path: `${basePath}/replies`,
 			scope: SUPPORT_THREADS_READ_SCOPE,
+			kind: "reads",
 			summary: "The canned reply catalog — starting points to pick from, ordered for a thread's category."
 		}
 	];
 }
 //#endregion
-export { SUPPORT_CONTROL_PLANE_SCOPES, SUPPORT_THREADS_ARCHIVE_SCOPE, SUPPORT_THREADS_FLAG_SCOPE, SUPPORT_THREADS_READ_SCOPE, SUPPORT_THREADS_RECLASSIFY_SCOPE, SUPPORT_THREADS_REPLY_SCOPE, supportAdminRoutes };
+export { SUPPORT_CONTROL_PLANE_SCOPES, SUPPORT_THREADS_ARCHIVE_SCOPE, SUPPORT_THREADS_ASSIGN_SCOPE, SUPPORT_THREADS_FLAG_SCOPE, SUPPORT_THREADS_READ_SCOPE, SUPPORT_THREADS_RECLASSIFY_SCOPE, SUPPORT_THREADS_REPLY_SCOPE, supportAdminRoutes };

package/dist/http/views.d.ts

@@ -1,14 +1,22 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
+import type { SupportAssignment } from "../data/assignment";
 import type { SupportMessage } from "../data/message";
 import type { SupportThread } from "../data/thread";
 import type { SenderContext } from "../link/sender";
+import type { SearchOutcome, SearchResult } from "../store/hybrid";
 import type { ListedThread } from "../store/threads";
-import type { SenderContextView, SupportAttachmentView, SupportListedThreadView, SupportMessageView, SupportMyMessageView, SupportMyThreadView, SupportThreadView } from "./responses";
+import type { SenderContextView, SupportAssignmentView, SupportAttachmentView, SupportListedThreadView, SupportMessageView, SupportMyMessageView, SupportMyThreadView, SupportSearchResponse, SupportSearchResultView, SupportThreadView } from "./responses";
 /** Project one thread row. */
 export declare function threadView(thread: SupportThread): SupportThreadView;
+/** Project one change of a thread's assignee. The thread id is the route's, so it is not repeated. */
+export declare function assignmentView(assignment: SupportAssignment): SupportAssignmentView;
 /** Project one thread for the inbox, carrying this viewer's own read and snooze state. */
 export declare function listedThreadView(thread: ListedThread): SupportListedThreadView;
+/** Project one search result: the thread as this viewer sees it, and its best message's raw scores. */
+export declare function searchResultView(result: SearchResult): SupportSearchResultView;
+/** Project a whole search. */
+export declare function searchView(outcome: SearchOutcome): SupportSearchResponse;
 /**
  * Project one message.
  *

package/dist/http/views.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../../src/http/views.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAyBrB,8BAA8B;AAC9B,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,CA2BnE;AAED,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,uBAAuB,CAE9E;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,kBAAkB,CAgBvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,mBAAmB,CASvE;AAED,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,qBAAqB,EAAE,GAAG,oBAAoB,CAYjH;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,CA4BnE"}
+{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../../src/http/views.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAyBrB,8BAA8B;AAC9B,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,CA+BnE;AAED,sGAAsG;AACtG,wBAAgB,cAAc,CAAC,UAAU,EAAE,iBAAiB,GAAG,qBAAqB,CAYnF;AAED,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,uBAAuB,CAE9E;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,uBAAuB,CAO9E;AAED,8BAA8B;AAC9B,wBAAgB,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,qBAAqB,CAOxE;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,kBAAkB,CAgBvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,mBAAmB,CASvE;AAED,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,qBAAqB,EAAE,GAAG,oBAAoB,CAYjH;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,CA4BnE"}

package/dist/http/views.js

@@ -44,6 +44,10 @@ function threadView(thread) {
 		archived: thread.archived,
 		archivedAt: iso(thread.archivedAt),
 		archivedBy: thread.archivedBy ?? null,
+		assigneeRef: thread.assigneeRef ?? null,
+		assigneeName: thread.assigneeName ?? null,
+		assignedAt: iso(thread.assignedAt),
+		assignedBy: thread.assignedBy ?? null,
 		messageCount: thread.messageCount,
 		firstMessageAt: thread.firstMessageAt.toISOString(),
 		lastMessageAt: thread.lastMessageAt.toISOString(),
@@ -51,6 +55,20 @@ function threadView(thread) {
 		updatedAt: thread.updatedAt.toISOString()
 	};
 }
+/** Project one change of a thread's assignee. The thread id is the route's, so it is not repeated. */
+function assignmentView(assignment) {
+	return {
+		id: assignment.id,
+		assigneeRef: assignment.assigneeRef ?? null,
+		assigneeName: assignment.assigneeName ?? null,
+		previousRef: assignment.previousRef ?? null,
+		previousName: assignment.previousName ?? null,
+		actorType: assignment.actorType,
+		assignedBy: assignment.assignedBy,
+		note: assignment.note ?? null,
+		createdAt: assignment.createdAt.toISOString()
+	};
+}
 /** Project one thread for the inbox, carrying this viewer's own read and snooze state. */
 function listedThreadView(thread) {
 	return {
@@ -59,6 +77,27 @@ function listedThreadView(thread) {
 		snoozedUntil: iso(thread.snoozedUntil)
 	};
 }
+/** Project one search result: the thread as this viewer sees it, and its best message's raw scores. */
+function searchResultView(result) {
+	return {
+		thread: listedThreadView(result.thread),
+		messageId: result.messageId,
+		...result.bm25 !== void 0 ? { bm25: result.bm25 } : {},
+		...result.similarity !== void 0 ? { similarity: result.similarity } : {}
+	};
+}
+/** Project a whole search. */
+function searchView(outcome) {
+	return {
+		mode: outcome.mode,
+		backends: {
+			ran: [...outcome.ran],
+			skipped: outcome.skipped.map((skip) => ({ ...skip }))
+		},
+		count: outcome.results.length,
+		results: outcome.results.map(searchResultView)
+	};
+}
 /**
 * Project one message.
 *
@@ -143,4 +182,4 @@ function senderView(sender) {
 	};
 }
 //#endregion
-export { listedThreadView, messageView, myMessageView, myThreadView, senderView, threadView };
+export { assignmentView, listedThreadView, messageView, myMessageView, myThreadView, searchResultView, searchView, senderView, threadView };

package/dist/inbound/ingest.d.ts

@@ -3,7 +3,7 @@
 import type { R2Bucket } from "@cloudflare/workers-types";
 import type { AuditEmit } from "@pithy-sh/core/src/audit/recorder";
 import type { Logger } from "@pithy-sh/core/src/logger/logger";
-import type { SupportConfig } from "../config/config";
+import { type SupportConfig } from "../config/config";
 import { type SupportDatabase } from "../data/tables";
 /**
  * Ingest — everything the `email()` handler does, with every dependency injected.