fix(chat-workflow): Next.js build — discriminated-union narrowing + supabase type depth

Two production-build issues surfaced by Vercel that local pnpm test +
tsc didn't catch (vitest uses esbuild transpile, no type check; tsc's
errors were all in __tests__ unrelated to this PR).
1. `compareAndSetChatActiveStreamId.ts` — `if (result.ok) { ... }`
narrowing wasn't kicking in under Next.js's strict TS plugin.
Switched to `if ("error" in result)` (in-operator narrowing) which
reliably discriminates the union members regardless of literal-type
inference quirks.
2. `lib/supabase/chats/updateChat.ts` — `let query = supabase.from(...)
.update(...).eq(...)` + reassignment in a `for` loop (`.is()` /
`.eq()` per where entry) caused "type instantiation is excessively
deep" — Supabase's PostgrestFilterBuilder is heavily generic and the
reassignment kept expanding the type. Rewrote as: split where map
into equality matches (one `.match(obj)` call) + nullable columns
(reduced with `.is(col, null)` typed back to the original builder).
Both bugs were behavior-neutral — the function shape and contract are
unchanged. 37/37 tests in touched files green; full suite 2955/2955;
lint clean; `pnpm build` now succeeds.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sweetmantech

lib/chat/compareAndSetChatActiveStreamId.ts

@@ -41,7 +41,7 @@ export async function compareAndSetChatActiveStreamId(
 {active_stream_id: next},
 );
 
-if(!result.ok){
+if("error"inresult){
 return{ok: false,error: result.error};
 }
 

lib/supabase/chats/__tests__/updateChat.test.ts

@@ -3,6 +3,7 @@ import { updateChat } from "@/lib/supabase/chats/updateChat";
 
 constupdateChain=vi.fn();
 consteqChain=vi.fn();
+constmatchChain=vi.fn();
 constisChain=vi.fn();
 constselectChain=vi.fn();
 
@@ -14,10 +15,12 @@ vi.mock("@/lib/supabase/serverClient", () => ({
 
 beforeEach(()=>{
 vi.clearAllMocks();
-// Any number of chained .eq() / .is() calls return the same fluent builder.
-constbuilder={eq: eqChain,is: isChain,select: selectChain};
+// Fluent builder mock — every method returns the same builder so we can
+// chain .eq / .match / .is / .select in any order without per-step setup.
+constbuilder={eq: eqChain,match: matchChain,is: isChain,select: selectChain};
 updateChain.mockReturnValue(builder);
 eqChain.mockReturnValue(builder);
+matchChain.mockReturnValue(builder);
 isChain.mockReturnValue(builder);
 });
 
@@ -33,6 +36,8 @@ describe("updateChat", () => {
 expect(result.row).toEqual(row);
 expect(updateChain).toHaveBeenCalledWith({title: "renamed"});
 expect(eqChain).toHaveBeenCalledWith("id","chat-1");
+// With no where filter, match is called with an empty object.
+expect(matchChain).toHaveBeenCalledWith({});
 });
 
 it("returns ok:false with error on Supabase failure",async()=>{
@@ -52,25 +57,29 @@ describe("updateChat", () => {
 {active_stream_id: "wrun_x"},
 );
 expect(isChain).toHaveBeenCalledWith("active_stream_id",null);
+// No non-null fields → match called with empty {}
+expect(matchChain).toHaveBeenCalledWith({});
 });
 
-it("emits `eq` for non-null values (e.g. CAS expecting a specific run id)",async()=>{
+it("emits `match()` for non-null values (e.g. CAS expecting a specific run id)",async()=>{
 selectChain.mockResolvedValue({data: [{id: "c-1"}],error: null});
 awaitupdateChat(
 {id: "c-1",where: {active_stream_id: "wrun_old"}},
 {active_stream_id: "wrun_new"},
 );
-expect(eqChain).toHaveBeenCalledWith("active_stream_id","wrun_old");
+expect(matchChain).toHaveBeenCalledWith({active_stream_id: "wrun_old"});
+// No null fields → is() not called
+expect(isChain).not.toHaveBeenCalled();
 });
 
-it("AND-s multiple where columns together",async()=>{
+it("AND-s nullable + equality where columns together",async()=>{
 selectChain.mockResolvedValue({data: [{id: "c-1"}],error: null});
 awaitupdateChat(
 {id: "c-1",where: {active_stream_id: null,model_id: "anthropic/claude-haiku-4.5"}},
 {title: "x"},
 );
 expect(isChain).toHaveBeenCalledWith("active_stream_id",null);
-expect(eqChain).toHaveBeenCalledWith("model_id","anthropic/claude-haiku-4.5");
+expect(matchChain).toHaveBeenCalledWith({model_id:"anthropic/claude-haiku-4.5"});
 });
 
 it("returns ok:true rowsUpdated:0 when the predicate matches no row (race lost)",async()=>{

lib/supabase/chats/updateChat.ts

@@ -46,12 +46,33 @@ export async function updateChat(
 filter: UpdateChatFilter,
 updates: ChatMutableFields,
 ): Promise<UpdateChatResult>{
-letquery=supabase.from("chats").update(updates).eq("id",filter.id);
-for(const[column,value]ofObject.entries(filter.where??{})){
-query=value===null ? query.is(column,null) : query.eq(column,value);
+// Split the optional `where` map into nullable vs equality predicates so we
+// can apply each as a single chained call (`.match()` for equalities,
+// `.is(col, null)` per nullable). Iterating with `let query = ...` and
+// reassigning in a for-loop confuses Supabase's deeply generic builder
+// types ("type instantiation is excessively deep") in the Next.js build.
+constentries=Object.entries(filter.where??{});
+constequalityMatches: Record<string,unknown>={};
+constnullColumns: string[]=[];
+for(const[column,value]ofentries){
+if(value===null){
+nullColumns.push(column);
+}else{
+equalityMatches[column]=value;
+}
 }
 
-const{ data, error }=awaitquery.select();
+constbaseQuery=supabase
+.from("chats")
+.update(updates)
+.eq("id",filter.id)
+.match(equalityMatches);
+constfinalQuery=nullColumns.reduce<typeofbaseQuery>(
+(q,column)=>q.is(column,null)astypeofbaseQuery,
+baseQuery,
+);
+
+const{ data, error }=awaitfinalQuery.select();
 if(error){
 console.error("[updateChat] error:",error);
 return{ok: false,error: error.message};