@memberjunction/server 6.2.0-edge.5 → 6.2.0-edge.6

package/src/resolvers/AgentRunStatusPublisher.ts

@@ -14,8 +14,10 @@ import type {
     AgentExecutionStreamingCallback,
     ExecuteAgentResult,
 } from '@memberjunction/ai-core-plus';
+import type { EntityInfo } from '@memberjunction/core';
 import type { UserPayload } from '../types.js';
-import { PublishStatusUpdate } from '../generic/PushStatusResolver.js';
+import { PublishStatusUpdate, StatusUpdateOwnerID } from '../generic/PushStatusResolver.js';
+import { ProjectEntityObjectForCaller } from '../generic/fieldSecurityTransport.js';
 
 const SIGNIFICANT_STEPS = ['prompt_execution', 'action_execution', 'subagent_execution', 'decision_processing'];
 
@@ -25,7 +27,8 @@ interface StatusRun {
     ConversationDetailID?: string;
     ErrorMessage?: string;
     Steps?: Array<{ StepName?: string }>;
-    GetAll?: () => unknown;
+    EntityInfo?: EntityInfo | null;
+    GetAll?: () => Record<string, unknown>;
 }
 
 export class AgentRunStatusPublisher {
@@ -34,11 +37,15 @@ export class AgentRunStatusPublisher {
     /**
      * @param sessionId Session stamped on the message body. Defaults to the payload's session.
      *   The push itself is always addressed to `userPayload.sessionId`, matching the resolver.
+     * @param conversationDetailId The run's reply row. When set, every message carries it as
+     *   `conversationDetailId`, not only the completion, so a client that reconnects mid-run can
+     *   find its row. When omitted, messages are as before.
      */
     constructor(
         private readonly pubSub: PubSubEngine,
         private readonly userPayload: UserPayload,
         private readonly sessionId: string = userPayload.sessionId,
+        private readonly conversationDetailId?: string,
     ) {}
 
     /** Latest run observed from a progress event, including steps that are not published. */
@@ -66,7 +73,8 @@ export class AgentRunStatusPublisher {
                 sessionId: this.sessionId,
                 agentRunId: agentRun.ID,
                 type: 'progress',
-                agentRun: agentRun.GetAll ? agentRun.GetAll() : agentRun,
+                ...this.replyRow(),
+                agentRun: this.runValues(agentRun),
                 progress: {
                     currentStep: progress.step,
                     percentage: progress.percentage,
@@ -93,7 +101,8 @@ export class AgentRunStatusPublisher {
                 sessionId: this.sessionId,
                 agentRunId: agentRun.ID,
                 type: 'streaming',
-                agentRun: agentRun.GetAll ? agentRun.GetAll() : agentRun,
+                ...this.replyRow(),
+                agentRun: this.runValues(agentRun),
                 streaming: {
                     content: chunk.content,
                     isPartial: !chunk.isComplete,
@@ -122,6 +131,7 @@ export class AgentRunStatusPublisher {
                 sessionId: this.sessionId,
                 agentRunId: agentRun.ID,
                 type: 'partial_result',
+                ...this.replyRow(),
                 partialResult: {
                     currentStep: lastStep,
                     partialOutput: result.payload || undefined,
@@ -134,7 +144,7 @@ export class AgentRunStatusPublisher {
             agentRunId: agentRun?.ID || 'unknown',
             type: 'complete',
             timestamp: new Date(),
-            conversationDetailId: conversationDetailId || agentRun?.ConversationDetailID,
+            conversationDetailId: conversationDetailId || agentRun?.ConversationDetailID || this.conversationDetailId,
             success: result.success,
             errorMessage: agentRun?.ErrorMessage || undefined,
             result: resultJson || undefined,
@@ -142,8 +152,9 @@ export class AgentRunStatusPublisher {
     }
 
     /**
-     * Completion for a failure that has no run. The fire-and-forget path uses this when
-     * `executeAIAgent` rejects. A host uses it the same way: when the turn throws
+     * Completion for a failure that has no run result. `executeAIAgent` sends it when the run
+     * throws (the agent could not start, the run failed, or its reply could not be saved), so a
+     * fire-and-forget client learns the reason. A host uses it the same way: when the turn throws
      * instead of returning a result, call `PublishFailure` with the reply row's id
      * and the error. That completion is what tells the chat the reply finished.
      */
@@ -160,10 +171,27 @@ export class AgentRunStatusPublisher {
         });
     }
 
+    /** `{ conversationDetailId }` when this run has a reply row, otherwise nothing, so the message keeps its old shape. */
+    private replyRow(): { conversationDetailId?: string } {
+        return this.conversationDetailId ? { conversationDetailId: this.conversationDetailId } : {};
+    }
+
+    /**
+     * The run's field values as the recipient may read them. The run object comes from the agent
+     * engine, which is not bound to this session's user, so it is projected here.
+     */
+    private runValues(agentRun: StatusRun): unknown {
+        if (!agentRun.GetAll) {
+            return agentRun;
+        }
+        const getAll = agentRun.GetAll;
+        return ProjectEntityObjectForCaller({ EntityInfo: agentRun.EntityInfo, GetAll: () => getAll.call(agentRun) }, this.userPayload?.userRecord);
+    }
+
     private publish(type: 'ExecutionProgress' | 'StreamingContent', data: unknown): void {
         PublishStatusUpdate(this.pubSub, {
             sessionId: this.userPayload.sessionId,
-            ownerUserId: this.userPayload?.userRecord?.ID ?? '',
+            ownerUserId: StatusUpdateOwnerID(this.userPayload),
             message: JSON.stringify({
                 resolver: 'RunAIAgentResolver',
                 type,

package/src/resolvers/AgentSessionResolver.ts

@@ -13,12 +13,30 @@
  */
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { UserInfo, IMetadataProvider, LogError } from '@memberjunction/core';
-import { UUIDsEqual } from '@memberjunction/global';
-import { MJAIAgentSessionEntity } from '@memberjunction/core-entities';
+import { UserInfo, IMetadataProvider } from '@memberjunction/core';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadWriteProvider } from '../util.js';
-import { SessionManager, SessionAuthorizationError } from '../agentSessions/index.js';
+import { SessionManager, SessionAuthorizationError, type SessionCloseReason } from '../agentSessions/index.js';
+import {
+    LoadOwnedRealtimeSession,
+    RealtimeSessionNotFoundError,
+    RealtimeSessionOwnershipError,
+} from '../realtimeSessions/ownedRealtimeSession.js';
+
+/** The `CloseReason` values a client may stamp on its own session; `Janitor` and `Shutdown` are the server's. */
+const CLIENT_CLOSE_REASONS: readonly SessionCloseReason[] = ['Explicit', 'Error'];
+
+/** Reads the mutation's optional `closeReason`: absent means `Explicit`; a server-only or unknown value is refused. */
+function ParseClientCloseReason(closeReason: string | null | undefined): SessionCloseReason {
+    if (closeReason == null || closeReason === '') {
+        return 'Explicit';
+    }
+    const match = CLIENT_CLOSE_REASONS.find((r) => r === closeReason);
+    if (!match) {
+        throw new Error(`Unsupported close reason '${closeReason}': a client may close its session as ${CLIENT_CLOSE_REASONS.join(' or ')}`);
+    }
+    return match;
+}
 
 /** Result of {@link AgentSessionResolver.StartAgentSession}. */
 @ObjectType()
@@ -77,15 +95,22 @@ export class AgentSessionResolver extends ResolverBase {
     /**
      * Close a session. Rejects unless the caller owns it. Returns `true` on a successful (or
      * idempotent) close, `false` if the session can't be loaded.
+     *
+     * `closeReason` is what the row records as its `CloseReason`: `Explicit` (the default, and what
+     * every client sent before the argument existed) when the user or host ended the call, `Error`
+     * when the client ended it because the start or the call failed (MJ#6013). The other reasons are
+     * the server's own (janitor, shutdown) and are refused from a client.
      */
     @Mutation(() => Boolean)
     async CloseAgentSession(
         @Arg('agentSessionId') agentSessionId: string,
         @Ctx() { userPayload, providers }: AppContext,
+        @Arg('closeReason', () => String, { nullable: true }) closeReason?: string | null,
     ): Promise<boolean> {
+        const reason = ParseClientCloseReason(closeReason);
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
-        await this.assertOwnership(agentSessionId, contextUser, provider);
-        return this.sessionManager.CloseSession(agentSessionId, contextUser, provider);
+        await this.loadOwnedSession(agentSessionId, contextUser, provider);
+        return this.sessionManager.CloseSession(agentSessionId, contextUser, provider, reason);
     }
 
     /**
@@ -98,7 +123,7 @@ export class AgentSessionResolver extends ResolverBase {
         @Ctx() { userPayload, providers }: AppContext,
     ): Promise<boolean> {
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
-        await this.assertOwnership(agentSessionId, contextUser, provider);
+        await this.loadOwnedSession(agentSessionId, contextUser, provider);
         return this.sessionManager.Heartbeat(agentSessionId, contextUser, provider);
     }
 
@@ -117,22 +142,25 @@ export class AgentSessionResolver extends ResolverBase {
     }
 
     /**
-     * Inbound ownership gate (the one genuinely new session-authz primitive): the session's `UserID`
-     * must equal the caller's. Throws on mismatch or when the session can't be loaded.
+     * Inbound ownership gate: delegates to {@link LoadOwnedRealtimeSession} (which enforces both
+     * `UserID === contextUser.ID` and `AuthorizeSessionAccess` scope/visitor binding) and maps its
+     * typed errors to this resolver's message format.
      */
-    private async assertOwnership(
+    private async loadOwnedSession(
         agentSessionId: string,
         contextUser: UserInfo,
         provider: IMetadataProvider,
     ): Promise<void> {
-        const session = await provider.GetEntityObject<MJAIAgentSessionEntity>('MJ: AI Agent Sessions', contextUser);
-        const loaded = await session.Load(agentSessionId);
-        if (!loaded) {
-            throw new Error(`Agent session ${agentSessionId} not found`);
-        }
-        if (!UUIDsEqual(session.UserID, contextUser.ID)) {
-            LogError(`AgentSessionResolver: ownership check failed — user ${contextUser.ID} attempted to operate on session ${agentSessionId} owned by ${session.UserID}`);
-            throw new Error('Not authorized: you do not own this agent session');
+        try {
+            await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
+        } catch (err) {
+            if (err instanceof RealtimeSessionNotFoundError) {
+                throw new Error(`Agent session ${agentSessionId} not found`);
+            }
+            if (err instanceof RealtimeSessionOwnershipError) {
+                throw new Error('Not authorized: you do not own this agent session');
+            }
+            throw err;
         }
     }
 }

package/src/resolvers/EntityCommunicationsResolver.ts

@@ -3,12 +3,14 @@ import { AppContext } from '../types.js';
 import { RunViewByIDInput } from '../generic/RunViewResolver.js';
 import { Message } from '@memberjunction/communication-types';
 import { EntityCommunicationsEngine } from '@memberjunction/entity-communications-server';
-import { RunViewParams } from '@memberjunction/core';
+import { DatabaseProviderBase, IMetadataProvider, RunViewParams, UserInfo } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { TemplateEngineServer } from '@memberjunction/templates';
 import { EntityCommunicationParams } from '@memberjunction/entity-communications-base';
 import { z } from 'zod';
 import { ResolverBase } from '../generic/ResolverBase.js';
+import { GetReadOnlyProvider } from '../util.js';
 
 @InputType()
 export class CommunicationProviderMessageType {
@@ -168,6 +170,11 @@ export class RunEntityCommunicationResultType {
 
 @Resolver(RunEntityCommunicationResultType)
 export class ReportResolver extends ResolverBase {
+  /**
+   * Runs a message against a view of records, as the caller. The recipient and related-entity reads
+   * run as the authenticated user, so a preview returns and a send merges only rows and fields that
+   * user may read. The view's client-supplied clauses get the same screen as a RunView request.
+   */
   @Query(() => RunEntityCommunicationResultType)
   async RunEntityCommunicationByViewID(
     @Arg('entityID', () => String) entityID: string,
@@ -177,25 +184,29 @@ export class ReportResolver extends ResolverBase {
     @Arg('message', () => CommunicationMessageInput) message: CommunicationMessageInput,
     @Arg('previewOnly', () => Boolean) previewOnly: boolean,
     @Arg('includeProcessedMessages', () => Boolean) includeProcessedMessages: boolean,
-    @Ctx() { userPayload }: AppContext
+    @Ctx() { userPayload, providers }: AppContext
   ): Promise<RunEntityCommunicationResultType> {
     // Check API key scope authorization for communication send
     await this.CheckAPIKeyScopeAuthorization('communication:send', entityID, userPayload);
 
     try {
-      await EntityCommunicationsEngine.Instance.Config(false, userPayload.userRecord);
-      const newMessage = new Message(message as unknown as Message);
-      await TemplateEngineServer.Instance.Config(false, userPayload.userRecord);
-      // for the templates, replace the values from the input with the objects from the Template Engine we have here
-      if (newMessage.BodyTemplate) {
-        newMessage.BodyTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.BodyTemplate.Name);
-      }
-      if (newMessage.HTMLBodyTemplate) {
-        newMessage.HTMLBodyTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.HTMLBodyTemplate.Name);
-      }
-      if (newMessage.SubjectTemplate) {
-        newMessage.SubjectTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.SubjectTemplate.Name);
-      }
+      const contextUser = this.GetUserFromPayload(userPayload);
+      if (!contextUser) throw new Error('Unable to determine the acting user for this communication');
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      this.screenClientViewClauses(
+        {
+          extraFilter: runViewByIDInput.ExtraFilter,
+          orderBy: runViewByIDInput.OrderBy,
+          userSearchString: runViewByIDInput.UserSearchString,
+          overrideExcludeFilter: runViewByIDInput.OverrideExcludeFilter,
+        },
+        provider as unknown as IMetadataProvider,
+        contextUser,
+      );
+      await this.assertViewBelongsToEntity(runViewByIDInput.ViewID, entityID, provider, contextUser);
+
+      await EntityCommunicationsEngine.Instance.Config(false, contextUser);
+      const newMessage = await this.resolveMessageTemplates(message, contextUser);
       const params: EntityCommunicationParams = {
         EntityID: entityID,
         RunViewParams: <RunViewParams>runViewByIDInput,
@@ -204,6 +215,8 @@ export class ReportResolver extends ResolverBase {
         Message: newMessage,
         PreviewOnly: previewOnly,
         IncludeProcessedMessages: includeProcessedMessages,
+        ContextUser: contextUser,
+        Provider: provider,
       };
       const result = await EntityCommunicationsEngine.Instance.RunEntityCommunication(params);
       return {
@@ -222,4 +235,32 @@ export class ReportResolver extends ResolverBase {
       };
     }
   }
+
+  /**
+   * Refuses a view that is not a view of `entityID`, with the same message as for a view that does
+   * not exist or that the caller cannot load, so the refusal does not reveal which views exist.
+   */
+  private async assertViewBelongsToEntity(viewID: string | undefined, entityID: string, provider: DatabaseProviderBase, contextUser: UserInfo): Promise<void> {
+    if (!viewID) return;
+    const view = await this.resolveUserViewByID(viewID, provider, contextUser);
+    if (!view?.ID || !UUIDsEqual(view.ID, viewID) || !UUIDsEqual(view.EntityID, entityID)) {
+      throw new Error('The requested view does not exist or you do not have access to it');
+    }
+  }
+
+  /** Builds the message, replacing each template the client named with the server's copy of it. */
+  private async resolveMessageTemplates(message: CommunicationMessageInput, contextUser: UserInfo): Promise<Message> {
+    const newMessage = new Message(message as unknown as Message);
+    await TemplateEngineServer.Instance.Config(false, contextUser);
+    if (newMessage.BodyTemplate) {
+      newMessage.BodyTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.BodyTemplate.Name);
+    }
+    if (newMessage.HTMLBodyTemplate) {
+      newMessage.HTMLBodyTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.HTMLBodyTemplate.Name);
+    }
+    if (newMessage.SubjectTemplate) {
+      newMessage.SubjectTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.SubjectTemplate.Name);
+    }
+    return newMessage;
+  }
 }

package/src/resolvers/FetchEntityVectorsResolver.ts

@@ -50,6 +50,12 @@ type LabelledVector = { row: StoredVectorRow; labels: Record<string, string> };
 /** Most Entity Record Document IDs named in one `ID IN (...)` filter when fetching VectorJSON. */
 const VECTOR_FETCH_CHUNK_SIZE = 1000;
 
+/** Most record keys named in one view when checking which matched records the caller may read. */
+const READABLE_KEY_CHECK_CHUNK_SIZE = 1000;
+
+/** A match returned by an external vector index's `QueryIndex`. */
+type IndexMatch = { id: string; values?: number[]; metadata?: Record<string, unknown>; score?: number };
+
 /* ───── Resolver ───── */
 
 @Resolver()
@@ -70,15 +76,18 @@ export class FetchEntityVectorsResolver extends ResolverBase {
             }
 
             const limit = maxRecords ?? 1000;
+            // Every read runs on this request's provider.
+            const md = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true }) ?? Metadata.Provider;
+            const rv = RunView.FromMetadataProvider(md);
 
             // Step 1: Load the EntityDocument
-            const entityDoc = await this.loadEntityDocument(entityDocumentID, currentUser);
+            const entityDoc = await this.loadEntityDocument(entityDocumentID, currentUser, rv);
             if (!entityDoc) {
                 return this.errorResult(`EntityDocument not found: ${entityDocumentID}`, startTime);
             }
 
             // Step 2: Resolve the VectorIndex
-            const vectorIndex = await this.resolveVectorIndex(entityDoc, currentUser);
+            const vectorIndex = await this.resolveVectorIndex(entityDoc, currentUser, rv);
             if (!vectorIndex) {
                 return this.errorResult(
                     `Could not resolve VectorIndex for EntityDocument "${entityDoc.Name}"`,
@@ -87,7 +96,7 @@ export class FetchEntityVectorsResolver extends ResolverBase {
             }
 
             // Step 3: Create VectorDB provider instance
-            const vectorDBInstance = await this.createVectorDBInstance(vectorIndex, currentUser);
+            const vectorDBInstance = await this.createVectorDBInstance(vectorIndex, currentUser, rv);
             if (!vectorDBInstance) {
                 return this.errorResult(
                     `Could not create VectorDB provider for index "${vectorIndex.Name}"`,
@@ -100,12 +109,21 @@ export class FetchEntityVectorsResolver extends ResolverBase {
             // document ID rather than the index name, and return matches without vector values.
             // Read the stored Entity Record Document rows instead.
             if (vectorDBInstance.QueryKeyIsEntityDocumentID) {
-                const md = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true }) ?? Metadata.Provider;
-                const results = await this.fetchStoredVectors(entityDoc, limit, filter, currentUser, md);
+                const results = await this.fetchStoredVectors(entityDoc, limit, filter, currentUser, md, rv);
                 LogStatus(`FetchEntityVectors: Loaded ${results.length} stored vectors for entity "${entityDoc.Entity}" in ${Date.now() - startTime}ms`);
                 return { Success: true, Results: results, TotalCount: results.length, ElapsedMs: Date.now() - startTime };
             }
 
+            // The external index was built under whoever ran the sync and is not filtered for this
+            // caller, so check here that they may read the source entity at all.
+            const entityInfo = this.readableEntity(entityDoc.Entity, currentUser, md);
+            if (!entityInfo) {
+                return this.errorResult(
+                    `Entity "${entityDoc.Entity}" does not exist or you do not have permission to read it`,
+                    startTime
+                );
+            }
+
             // Step 4: Query with zero vector + Entity metadata filter.
             // Pinecone's list API doesn't support metadata filtering, but query does.
             // A zero vector returns results in arbitrary order (similarity is meaningless),
@@ -136,12 +154,15 @@ export class FetchEntityVectorsResolver extends ResolverBase {
                 );
             }
 
-            // Step 5: Convert query matches to result format
-            const matches = (queryResponse.data as { matches?: Array<{ id: string; values?: number[]; metadata?: Record<string, unknown>; score?: number }> }).matches ?? [];
+            // Step 5: Keep only matches for records this caller may read (the index is not filtered
+            // by row-level security), then convert them without the fields this caller may not read
+            const allMatches = (queryResponse.data as { matches?: IndexMatch[] }).matches ?? [];
+            const matches = await this.readableMatches(entityInfo, allMatches, currentUser, rv);
+            const denied = entityInfo.GetDeniedReadFields(currentUser);
             const results: EntityVectorItem[] = matches.map(match => ({
                 ID: match.id,
                 Values: match.values ?? [],
-                Metadata: JSON.stringify(match.metadata ?? {}),
+                Metadata: JSON.stringify(this.withoutDeniedFields(match.metadata ?? {}, denied)),
             }));
             LogStatus(`FetchEntityVectors: Queried ${results.length} vectors for entity "${entityName}" in ${Date.now() - startTime}ms`);
 
@@ -158,12 +179,100 @@ export class FetchEntityVectorsResolver extends ResolverBase {
         }
     }
 
+    /**
+     * The entity's metadata when `contextUser` may read it, else null — whether it is missing or
+     * unreadable is deliberately not distinguished.
+     */
+    private readableEntity(entityName: string, contextUser: UserInfo, md: IMetadataProvider): EntityInfo | null {
+        const entityInfo = md.EntityByName(entityName);
+        if (!entityInfo) return null;
+        return entityInfo.GetUserPermisions(contextUser)?.CanRead ? entityInfo : null;
+    }
+
+    /**
+     * The matches whose record `contextUser` may read, in their original order. A match is kept only
+     * when its `RecordID` metadata names a key of the entity and a view run as `contextUser` returns
+     * that record; a match without a usable record ID cannot be checked, so it is dropped.
+     */
+    private async readableMatches(entityInfo: EntityInfo, matches: IndexMatch[], contextUser: UserInfo, rv: RunView): Promise<IndexMatch[]> {
+        const keyed = matches
+            .map(match => ({ match, key: this.matchRecordKey(entityInfo, match) }))
+            .filter((m): m is { match: IndexMatch; key: CompositeKey } => m.key !== null);
+        if (keyed.length === 0) return [];
+        const readable = await this.loadReadableKeys(entityInfo, keyed.map(k => k.key), contextUser, rv);
+        return keyed.filter(k => readable.has(this.canonicalKey(k.key))).map(k => k.match);
+    }
+
+    /** The record key a match's `RecordID` metadata names, or null when it names no key of the entity. */
+    private matchRecordKey(entityInfo: EntityInfo, match: IndexMatch): CompositeKey | null {
+        const recordID = match.metadata?.RecordID;
+        if (typeof recordID !== 'string' || recordID.length === 0) return null;
+        try {
+            return CompositeKey.FromRecordID(entityInfo, recordID);
+        } catch {
+            return null; // field names that are not the entity's primary key: never put into SQL
+        }
+    }
+
+    /**
+     * The canonical forms of the keys among `keys` whose record a view run as `contextUser` returns.
+     * The keys are checked in lists of at most {@link READABLE_KEY_CHECK_CHUNK_SIZE}, all sent in one
+     * `RunViews` batch.
+     */
+    private async loadReadableKeys(entityInfo: EntityInfo, keys: CompositeKey[], contextUser: UserInfo, rv: RunView): Promise<Set<string>> {
+        const views: RunViewParams[] = [];
+        for (let i = 0; i < keys.length; i += READABLE_KEY_CHECK_CHUNK_SIZE) {
+            views.push({
+                EntityName: entityInfo.Name,
+                ExtraFilter: this.keyFilter(entityInfo, keys.slice(i, i + READABLE_KEY_CHECK_CHUNK_SIZE)),
+                Fields: entityInfo.PrimaryKeys.map(pk => pk.Name),
+                IgnoreMaxRows: true,
+                BypassCache: true, // one-off key lists: a cache slot per call would only hold memory
+                ResultType: 'simple',
+            });
+        }
+        const readable = new Set<string>();
+        const results = await rv.RunViews<Record<string, unknown>>(views, contextUser);
+        for (const result of results) {
+            if (!result.Success) {
+                throw new Error(`Failed to check access to "${entityInfo.Name}" records: ${result.ErrorMessage}`);
+            }
+            for (const row of result.Results) {
+                readable.add(this.canonicalKey(CompositeKey.FromEntityRecord(entityInfo, row)));
+            }
+        }
+        return readable;
+    }
+
+    /** A filter matching exactly `keys`: `PK IN (...)` for a single-column key, one clause per key otherwise. */
+    private keyFilter(entityInfo: EntityInfo, keys: CompositeKey[]): string {
+        if (entityInfo.PrimaryKeys.length === 1) {
+            const values = keys.map(k => `'${EscapeSQLString(String(k.KeyValuePairs[0].Value))}'`).join(',');
+            return `${entityInfo.FirstPrimaryKey.Name} IN (${values})`; // first-pk-ok: single-column key, checked above
+        }
+        return keys.map(k => `(${k.ToWhereClause()})`).join(' OR ');
+    }
+
+    /** A key's field names and values, lower-cased, so keys from the index and from a view compare equal. */
+    private canonicalKey(key: CompositeKey): string {
+        return key.KeyValuePairs.map(kv => `${kv.FieldName.toLowerCase()}|${String(kv.Value).toLowerCase()}`).join('||');
+    }
+
+    /**
+     * A copy of a vector's metadata without the keys naming fields in `denied` (lowercased field
+     * names, as `EntityInfo.GetDeniedReadFields` returns them), compared case-insensitively.
+     */
+    private withoutDeniedFields(metadata: Record<string, unknown>, denied: Set<string>): Record<string, unknown> {
+        if (denied.size === 0) return metadata;
+        return Object.fromEntries(Object.entries(metadata).filter(([key]) => !denied.has(key.toLowerCase())));
+    }
+
     /** Load EntityDocument by ID */
     private async loadEntityDocument(
         entityDocumentID: string,
-        contextUser: UserInfo
+        contextUser: UserInfo,
+        rv: RunView
     ): Promise<MJEntityDocumentEntity | null> {
-        const rv = new RunView();
         const result = await rv.RunView<MJEntityDocumentEntity>({
             EntityName: 'MJ: Entity Documents',
             ExtraFilter: `ID='${EscapeSQLString(entityDocumentID)}'`,
@@ -183,9 +292,9 @@ export class FetchEntityVectorsResolver extends ResolverBase {
      */
     private async resolveVectorIndex(
         entityDoc: MJEntityDocumentEntity,
-        contextUser: UserInfo
+        contextUser: UserInfo,
+        rv: RunView
     ): Promise<MJVectorIndexEntity | null> {
-        const rv = new RunView();
 
         // If the EntityDocument has an explicit VectorIndexID, use it directly
         if (entityDoc.VectorIndexID) {
@@ -222,9 +331,9 @@ export class FetchEntityVectorsResolver extends ResolverBase {
     /** Create a VectorDBBase provider instance for a given VectorIndex */
     private async createVectorDBInstance(
         vectorIndex: MJVectorIndexEntity,
-        contextUser: UserInfo
+        contextUser: UserInfo,
+        rv: RunView
     ): Promise<VectorDBBase | null> {
-        const rv = new RunView();
         const dbResult = await rv.RunView<MJVectorDatabaseEntity>({
             EntityName: 'MJ: Vector Databases',
             ExtraFilter: `ID='${vectorIndex.VectorDatabaseID}'`,
@@ -258,19 +367,20 @@ export class FetchEntityVectorsResolver extends ResolverBase {
         limit: number,
         filter: string | undefined,
         contextUser: UserInfo,
-        md: IMetadataProvider
+        md: IMetadataProvider,
+        rv: RunView
     ): Promise<EntityVectorItem[]> {
         const entityInfo = md.EntityByName(entityDoc.Entity);
         if (!entityInfo) {
             throw new Error(`Entity "${entityDoc.Entity}" not found in metadata`);
         }
         const nameFields = this.labelFieldNames(entityInfo);
-        const { records, vectors } = await this.loadRecordsAndStoredVectors(entityInfo, entityDoc, nameFields, filter, contextUser);
+        const { records, vectors } = await this.loadRecordsAndStoredVectors(entityInfo, entityDoc, nameFields, filter, contextUser, rv);
         const labelsByRecordID = this.mapRecordLabels(entityInfo, nameFields, records);
 
         // VectorJSON is the heavy column: list without it, then fetch it only for the items returned.
         const chosen = this.selectLabelledVectors(vectors, labelsByRecordID, limit);
-        const valuesByID = await this.loadVectorValues(chosen.map(c => c.row.ID), contextUser);
+        const valuesByID = await this.loadVectorValues(chosen.map(c => c.row.ID), contextUser, rv);
 
         const results: EntityVectorItem[] = [];
         for (const { row, labels } of chosen) {
@@ -305,7 +415,7 @@ export class FetchEntityVectorsResolver extends ResolverBase {
      * Fetch `VectorJSON` for the given Entity Record Document IDs, keyed by ID. The ID lists are
      * capped at {@link VECTOR_FETCH_CHUNK_SIZE} per view and all sent in one `RunViews` batch.
      */
-    private async loadVectorValues(ids: string[], contextUser: UserInfo): Promise<Map<string, string>> {
+    private async loadVectorValues(ids: string[], contextUser: UserInfo, rv: RunView): Promise<Map<string, string>> {
         const valuesByID = new Map<string, string>();
         if (ids.length === 0) return valuesByID;
 
@@ -321,7 +431,7 @@ export class FetchEntityVectorsResolver extends ResolverBase {
                 ResultType: 'simple',
             });
         }
-        const results = await new RunView().RunViews<{ ID: string; VectorJSON: string | null }>(views, contextUser);
+        const results = await rv.RunViews<{ ID: string; VectorJSON: string | null }>(views, contextUser);
         for (const result of results) {
             if (!result.Success) {
                 throw new Error(`Failed to load vector values: ${result.ErrorMessage}`);
@@ -352,10 +462,11 @@ export class FetchEntityVectorsResolver extends ResolverBase {
         entityDoc: MJEntityDocumentEntity,
         nameFields: string[],
         filter: string | undefined,
-        contextUser: UserInfo
+        contextUser: UserInfo,
+        rv: RunView
     ): Promise<{ records: Record<string, unknown>[]; vectors: StoredVectorRow[] }> {
         const keyFields = entityInfo.PrimaryKeys.map(pk => pk.Name);
-        const [recordResult, docResult] = await new RunView().RunViews<Record<string, unknown>>([
+        const [recordResult, docResult] = await rv.RunViews<Record<string, unknown>>([
             {
                 EntityName: entityInfo.Name,
                 ExtraFilter: filter || undefined,

package/src/resolvers/FileCategoryResolver.ts

@@ -34,6 +34,7 @@ export class FileCategoryResolver extends FileCategoryResolverBase {
     fileCategoryEntity.CheckPermissions(EntityPermissionType.Delete, true);
 
     await fileCategoryEntity.Load(ID);
+    // fls-guard: loaded as the caller; width follows its user
     const returnValue = fileCategoryEntity.GetAll();
 
     // Any files using the deleted category fall back to its parent