@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/store/slices/chatSlice.test.ts

@@ -8,7 +8,7 @@ import { buildErrorFeedbackContent } from './chatSlice.js';
 import { create } from 'zustand';
 import { createChatSlice, type ChatSlice } from './chatSlice.js';
 import { createPatchDiagnostic, createPreflightDiagnostic } from '../../lib/llm/script-diagnostics.js';
-import { DEFAULT_FREE_MODEL, DEFAULT_PRO_MODEL } from '../../lib/llm/models.js';
+import { DEFAULT_FREE_MODEL, DEFAULT_BYOK_MODEL } from '../../lib/llm/models.js';
 
 function withMockLocalStorage(fn: () => void) {
   const original = globalThis.localStorage;
@@ -217,52 +217,14 @@ test('clearChatMessages resets streaming state as well as persisted messages', (
   assert.deepEqual(useChatStore.getState().chatAttachments, []);
 });
 
-test('switchChatUserContext restores per-user history and coerces disallowed models', () => {
-  withMockLocalStorage(() => {
-    globalThis.localStorage.setItem('ifc-lite-chat-model:user-a', DEFAULT_PRO_MODEL.id);
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-a', JSON.stringify([
-      {
-        id: 'persisted-a',
-        role: 'user',
-        content: 'hello from A',
-        createdAt: 1,
-      },
-    ]));
-    globalThis.localStorage.setItem('ifc-lite-chat-model:user-b', DEFAULT_FREE_MODEL.id);
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-b', JSON.stringify([
-      {
-        id: 'persisted-b',
-        role: 'assistant',
-        content: 'hello from B',
-        createdAt: 2,
-      },
-    ]));
-
-    const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-    useChatStore.getState().switchChatUserContext('user-a', true, { restoreMessages: true });
-
-    assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_PRO_MODEL.id);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'persisted-a');
-
-    useChatStore.getState().switchChatUserContext('user-b', false, {
-      clearPersistedCurrent: true,
-      restoreMessages: true,
-    });
-
-    assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_FREE_MODEL.id);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'persisted-b');
-    assert.equal(globalThis.localStorage.getItem('ifc-lite-chat-messages:user-a'), null);
-  });
-});
-
-test('setChatHasPro falls back to a free model when entitlement is removed', () => {
+test('setChatHasByokKey falls back to a free model when keys are removed', () => {
   const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-  useChatStore.getState().setChatHasPro(true);
-  useChatStore.getState().setChatActiveModel(DEFAULT_PRO_MODEL.id);
+  useChatStore.getState().setChatHasByokKey(true);
+  useChatStore.getState().setChatActiveModel(DEFAULT_BYOK_MODEL.id);
 
-  useChatStore.getState().setChatHasPro(false);
+  useChatStore.getState().setChatHasByokKey(false);
 
-  assert.equal(useChatStore.getState().chatHasPro, false);
+  assert.equal(useChatStore.getState().chatHasByokKey, false);
   assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_FREE_MODEL.id);
 });
 
@@ -291,35 +253,3 @@ test('removeChatAttachment only removes the targeted attachment id', () => {
   );
 });
 
-test('switchChatUserContext ignores malformed persisted messages', () => {
-  withMockLocalStorage(() => {
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-a', JSON.stringify([
-      {
-        id: 'valid',
-        role: 'user',
-        content: 'hello',
-        createdAt: 1,
-        attachments: [
-          { id: 'att-1', name: 'ok.csv', type: 'text/csv', size: 20, textContent: 'a,b\n1,2' },
-          { name: 'missing-id.csv', type: 'text/csv', size: 20 },
-        ],
-      },
-      {
-        id: 123,
-        role: 'assistant',
-        content: 'bad',
-        createdAt: 2,
-      },
-    ]));
-
-    const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-    useChatStore.getState().switchChatUserContext('user-a', false, { restoreMessages: true });
-
-    assert.equal(useChatStore.getState().chatMessages.length, 1);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'valid');
-    assert.deepEqual(
-      useChatStore.getState().chatMessages[0]?.attachments?.map((attachment) => attachment.id),
-      ['att-1'],
-    );
-  });
-});

package/src/store/slices/chatSlice.ts

@@ -13,6 +13,7 @@ import { coerceModelForEntitlement, DEFAULT_FREE_MODEL } from '../../lib/llm/mod
 import { extractCodeBlocks } from '../../lib/llm/code-extractor.js';
 import type { ScriptDiagnostic } from '../../lib/llm/script-diagnostics.js';
 import { formatDiagnosticsForPrompt, getPrimaryRootCause, groupDiagnosticsByRootCause } from '../../lib/llm/script-diagnostics.js';
+import { hasAnyApiKey as hasAnyApiKeyAtInit } from '../../services/api-keys.js';
 
 const MODEL_STORAGE_KEY = 'ifc-lite-chat-model';
 const MESSAGES_STORAGE_KEY = 'ifc-lite-chat-messages';
@@ -43,11 +44,9 @@ export interface ChatSlice {
   chatPendingRepairRequest: ChatRepairRequest | null;
   /** Auto-captured viewport screenshot (base64 data URL) to include with next LLM message */
   chatViewportScreenshot: string | null;
-  /** Clerk JWT for authenticated API calls (null for anonymous/free tier) */
-  chatAuthToken: string | null;
-  /** Whether the current user has a pro subscription */
-  chatHasPro: boolean;
-  /** Usage info from the server: credits (pro) or request count (free) */
+  /** Whether the user has at least one BYOK API key configured */
+  chatHasByokKey: boolean;
+  /** Usage info from the proxy: request count for free tier */
   chatUsage: ChatUsage | null;
   /** User ID used to scope persisted model preference (null for anonymous). */
   chatStorageUserId: string | null;
@@ -78,18 +77,10 @@ export interface ChatSlice {
   sendErrorFeedback: (code: string, error: string) => void;
   /** Store a viewport screenshot to include with the next LLM message */
   setChatViewportScreenshot: (dataUrl: string | null) => void;
-  /** Set the Clerk auth token (called by ClerkProvider wrapper when user signs in) */
-  setChatAuthToken: (token: string | null) => void;
-  /** Set whether user has pro subscription (called by ClerkProvider wrapper) */
-  setChatHasPro: (hasPro: boolean) => void;
+  /** Set whether user has at least one BYOK API key configured */
+  setChatHasByokKey: (hasByokKey: boolean) => void;
   /** Update usage info from server response headers */
   setChatUsage: (usage: ChatUsage | null) => void;
-  /** Switch the active chat user/session context. */
-  switchChatUserContext: (
-    userId: string | null,
-    hasPro: boolean,
-    options?: { clearPersistedCurrent?: boolean; restoreMessages?: boolean },
-  ) => void;
 }
 
 export interface ChatUsage {
@@ -279,7 +270,7 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   chatMessages: loadStoredMessages(null),
   chatStatus: 'idle',
   chatStreamingContent: '',
-  chatActiveModel: loadValidStoredModel(null, false),
+  chatActiveModel: loadValidStoredModel(null, hasAnyApiKeyAtInit()),
   chatAutoExecute: loadStoredAutoExecute(),
   chatError: null,
   chatAbortController: null,
@@ -287,8 +278,7 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   chatPendingPrompt: null,
   chatPendingRepairRequest: null,
   chatViewportScreenshot: null,
-  chatAuthToken: null,
-  chatHasPro: false,
+  chatHasByokKey: false,
   chatUsage: null,
   chatStorageUserId: null,
 
@@ -340,12 +330,15 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   setChatStreamingContent: (chatStreamingContent) => set({ chatStreamingContent }),
 
   setChatActiveModel: (chatActiveModel) => {
-    const nextModel = coerceModelForEntitlement(chatActiveModel, get().chatHasPro);
+    // Accept any model the user picks — the ChatPanel shows an inline key
+    // prompt if the selected BYOK model doesn't have a key yet, and guards
+    // the send path. Coercion only happens on init and when keys are removed
+    // (via setChatHasByokKey).
     try {
       const key = getModelStorageKey(get().chatStorageUserId);
-      localStorage.setItem(key, nextModel);
+      localStorage.setItem(key, chatActiveModel);
     } catch { /* ignore */ }
-    set({ chatActiveModel: nextModel });
+    set({ chatActiveModel });
   },
 
   setChatAutoExecute: (chatAutoExecute) => {
@@ -404,51 +397,17 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
 
   setChatViewportScreenshot: (chatViewportScreenshot) => set({ chatViewportScreenshot }),
 
-  setChatAuthToken: (chatAuthToken) => set({ chatAuthToken }),
-
-  setChatHasPro: (chatHasPro) => {
-    const nextModel = coerceModelForEntitlement(get().chatActiveModel, chatHasPro);
+  setChatHasByokKey: (chatHasByokKey) => {
+    const nextModel = coerceModelForEntitlement(get().chatActiveModel, chatHasByokKey);
     try {
       const key = getModelStorageKey(get().chatStorageUserId);
       localStorage.setItem(key, nextModel);
     } catch { /* ignore */ }
-    set({ chatHasPro, chatActiveModel: nextModel });
+    set({ chatHasByokKey, chatActiveModel: nextModel });
   },
 
   setChatUsage: (chatUsage) => set({ chatUsage }),
 
-  switchChatUserContext: (chatStorageUserId, chatHasPro, options) => {
-    const state = get();
-    state.chatAbortController?.abort();
-    if (options?.clearPersistedCurrent) {
-      try {
-        localStorage.removeItem(getMessagesStorageKey(state.chatStorageUserId));
-      } catch { /* ignore */ }
-    }
-    const restoredModel = coerceModelForEntitlement(
-      loadStoredModel(chatStorageUserId, state.chatActiveModel),
-      chatHasPro,
-    );
-    const restoredMessages = options?.restoreMessages === false
-      ? []
-      : loadStoredMessages(chatStorageUserId);
-    set({
-      chatStorageUserId,
-      chatHasPro,
-      chatActiveModel: restoredModel,
-      chatMessages: restoredMessages,
-      chatStatus: 'idle',
-      chatStreamingContent: '',
-      chatError: null,
-      chatAbortController: null,
-      chatAttachments: [],
-      chatPendingPrompt: null,
-      chatPendingRepairRequest: null,
-      chatViewportScreenshot: null,
-      chatUsage: null,
-    });
-  },
-
   sendErrorFeedback: (code, error) => {
     const feedbackMessage: ChatMessage = {
       id: crypto.randomUUID(),

package/src/store/slices/dataSlice.test.ts

@@ -4,9 +4,11 @@
 
 import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert';
-import { createDataSlice, type DataSlice } from './dataSlice.js';
+import { createDataSlice, type DataSlice, type DataCrossSliceState } from './dataSlice.js';
 import { DATA_DEFAULTS } from '../constants.js';
 
+type DataTestState = DataSlice & DataCrossSliceState;
+
 // Mock mesh data for testing
 const createMockMesh = (expressId: number, color: [number, number, number, number] = [1, 0, 0, 1]) => ({
   expressId,
@@ -17,9 +19,16 @@ const createMockMesh = (expressId: number, color: [number, number, number, numbe
   ifcType: 'IfcWall',
 });
 
+type TestSetState = (
+  partial:
+    | Partial<DataTestState>
+    | ((state: DataTestState) => Partial<DataTestState>),
+) => void;
+type TestGetState = () => DataTestState;
+
 describe('DataSlice', () => {
-  let state: DataSlice;
-  let setState: (partial: Partial<DataSlice> | ((state: DataSlice) => Partial<DataSlice>)) => void;
+  let state: DataTestState;
+  let setState: TestSetState;
 
   beforeEach(() => {
     setState = (partial) => {
@@ -31,7 +40,17 @@ describe('DataSlice', () => {
       }
     };
 
-    state = createDataSlice(setState, () => state, {} as any);
+    const getState: TestGetState = () => state;
+
+    // Seed the cross-slice fields owned by ModelSlice. dataSlice's
+    // updaters look up the active model in this map, so the test mock
+    // has to provide it for the typed StateCreator to be satisfiable.
+    const slice = createDataSlice(
+      setState as Parameters<typeof createDataSlice>[0],
+      getState as Parameters<typeof createDataSlice>[1],
+      undefined as unknown as Parameters<typeof createDataSlice>[2],
+    );
+    state = { ...slice, activeModelId: null, models: new Map() };
   });
 
   describe('initial state', () => {

package/src/store/slices/dataSlice.ts

@@ -20,7 +20,7 @@ import { DATA_DEFAULTS } from '../constants.js';
  * consistent.  The types below describe the minimal ModelSlice surface
  * that dataSlice accesses through the merged Zustand state.
  */
-interface DataCrossSliceState {
+export interface DataCrossSliceState {
   activeModelId: string | null;
   models: Map<string, FederatedModel>;
 }

package/src/store/slices/modelSlice.test.ts

@@ -4,16 +4,34 @@
 
 import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert';
-import { createModelSlice, type ModelSlice } from './modelSlice.js';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { GeometryResult } from '@ifc-lite/geometry';
+import { createModelSlice, type ModelSlice, type ModelCrossSliceState } from './modelSlice.js';
 import type { FederatedModel } from '../types.js';
 
-// Helper to create a mock model
+type ModelTestState = ModelSlice & ModelCrossSliceState;
+
+// Typed setter / getter shim that mirrors zustand's StateCreator
+// signature without the broader middleware machinery the test doesn't
+// need. Using StateCreator's exact types here would pull in the whole
+// store; the local aliases below are tight enough for this test.
+type TestSetState = (
+  partial:
+    | Partial<ModelTestState>
+    | ((state: ModelTestState) => Partial<ModelTestState>),
+) => void;
+type TestGetState = () => ModelTestState;
+
+// Helper to create a mock model. `IfcDataStore` and `GeometryResult` are
+// large interfaces that the slice never inspects on these paths — the
+// double-cast through `unknown` is the minimum that satisfies the
+// compiler without an `any`.
 function createMockModel(id: string, name: string): FederatedModel {
   return {
     id,
     name,
-    ifcDataStore: {} as any,
-    geometryResult: {} as any,
+    ifcDataStore: {} as unknown as IfcDataStore,
+    geometryResult: {} as unknown as GeometryResult,
     visible: true,
     collapsed: false,
     schemaVersion: 'IFC4',
@@ -25,11 +43,10 @@ function createMockModel(id: string, name: string): FederatedModel {
 }
 
 describe('ModelSlice', () => {
-  let state: ModelSlice;
-  let setState: (partial: Partial<ModelSlice> | ((state: ModelSlice) => Partial<ModelSlice>)) => void;
+  let state: ModelTestState;
+  let setState: TestSetState;
 
   beforeEach(() => {
-    // Create a mock set function that updates state
     setState = (partial) => {
       if (typeof partial === 'function') {
         const updates = partial(state);
@@ -39,8 +56,17 @@ describe('ModelSlice', () => {
       }
     };
 
-    // Create slice with mock set function
-    state = createModelSlice(setState, () => state, {} as any);
+    const getState: TestGetState = () => state;
+
+    // The slice's StateCreator signature includes a third middleware
+    // argument (store API) that the slice's body never reads. We pass
+    // `undefined` cast to the empty middleware shape rather than `any`.
+    const slice = createModelSlice(
+      setState as Parameters<typeof createModelSlice>[0],
+      getState as Parameters<typeof createModelSlice>[1],
+      undefined as unknown as Parameters<typeof createModelSlice>[2],
+    );
+    state = { ...slice, ifcDataStore: null, geometryResult: null };
   });
 
   describe('initial state', () => {
@@ -270,4 +296,36 @@ describe('ModelSlice', () => {
       assert.strictEqual(visible.length, 0);
     });
   });
+
+  describe('resolveGlobalIdFromModels — overlay-allocated ids', () => {
+    it('falls through to mutation views when the id is past maxExpressId', () => {
+      const model = createMockModel('model-1', 'First');
+      model.idOffset = 0;
+      model.maxExpressId = 10_000;
+      state.addModel(model);
+
+      // Seed a fake mutation view with a fresh overlay entity. The
+      // resolver only reads `getNewEntity` from each view, so we type
+      // the map narrowly and let it satisfy the slice's wider type via
+      // a single-property cast on the wrapping state object.
+      type StubView = { getNewEntity: (id: number) => { expressId: number } | null };
+      const stubViews: Map<string, StubView> = new Map([
+        ['model-1', { getNewEntity: (id: number) => (id === 11_001 ? { expressId: id } : null) }],
+      ]);
+      state = { ...state, mutationViews: stubViews } as typeof state & { mutationViews: Map<string, StubView> };
+
+      // Inside the parsed range — first pass resolves it.
+      const within = state.resolveGlobalIdFromModels(42);
+      assert.deepStrictEqual(within, { modelId: 'model-1', expressId: 42 });
+
+      // Above the parsed range but in the overlay — second pass resolves it.
+      const overlay = state.resolveGlobalIdFromModels(11_001);
+      assert.deepStrictEqual(overlay, { modelId: 'model-1', expressId: 11_001 });
+
+      // Above the parsed range and NOT in the overlay — returns null
+      // so callers can fall back to the legacy single-model path.
+      const phantom = state.resolveGlobalIdFromModels(99_999);
+      assert.strictEqual(phantom, null);
+    });
+  });
 });

package/src/store/slices/modelSlice.ts

@@ -13,8 +13,20 @@
 
 import type { StateCreator } from 'zustand';
 import type { FederatedModel } from '../types.js';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { GeometryResult } from '@ifc-lite/geometry';
 import { federationRegistry, type GlobalIdLookup } from '@ifc-lite/renderer';
 
+/**
+ * Cross-slice fields the model actions write to. `ifcDataStore` and
+ * `geometryResult` are owned by `dataSlice` but `modelSlice`'s set()
+ * calls need to keep them in sync with the active model.
+ */
+export interface ModelCrossSliceState {
+  ifcDataStore: IfcDataStore | null;
+  geometryResult: GeometryResult | null;
+}
+
 export interface ModelSlice {
   // State
   /** Map of all loaded models by ID */
@@ -72,7 +84,7 @@ export interface ModelSlice {
   resolveGlobalIdFromModels: (globalId: number) => GlobalIdLookup | null;
 }
 
-export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (set, get) => ({
+export const createModelSlice: StateCreator<ModelSlice & ModelCrossSliceState, [], [], ModelSlice> = (set, get) => ({
   // Initial state
   models: new Map(),
   activeModelId: null,
@@ -245,19 +257,39 @@ export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (s
    */
   resolveGlobalIdFromModels: (globalId: number) => {
     const models = get().models;
+    const mutationViews = (get() as unknown as { mutationViews?: Map<string, { getNewEntity: (id: number) => unknown }> }).mutationViews;
 
     // Sort models by offset for correct range checking
     const sortedModels = Array.from(models.values()).sort((a, b) => a.idOffset - b.idOffset);
 
-    // Find the model that contains this globalId
-    // A model contains a globalId if: offset <= globalId <= offset + maxExpressId
+    // Find the model that contains this globalId.
+    //
+    // First pass — parse-time range. A model owns ids in
+    // `[offset, offset + maxExpressId]` from the original parse. This
+    // is the fast path covering 99% of selections.
+    //
+    // Second pass — overlay-allocated ids. Duplicates / scripted adds
+    // through StoreEditor land ABOVE the model's parse-time
+    // maxExpressId, so they fall outside the first-pass range. The
+    // federation resolver knows nothing about overlay state, so we
+    // consult each model's mutation view for the freshly-added
+    // entity. Falls back gracefully when no view is registered.
     for (const model of sortedModels) {
       const localId = globalId - model.idOffset;
       if (localId >= 0 && localId <= model.maxExpressId) {
-        return {
-          modelId: model.id,
-          expressId: localId,
-        };
+        return { modelId: model.id, expressId: localId };
+      }
+    }
+
+    if (mutationViews) {
+      for (const model of sortedModels) {
+        const localId = globalId - model.idOffset;
+        if (localId <= model.maxExpressId) continue; // already covered above
+        const view = mutationViews.get(model.id);
+        if (!view) continue;
+        if (view.getNewEntity(localId) !== null) {
+          return { modelId: model.id, expressId: localId };
+        }
       }
     }