@memberjunction/server 5.42.0 → 5.43.0

package/src/generated/generated.ts

@@ -45276,6 +45276,10 @@ export class MJEntityActionInvocation_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field({nullable: true, description: `Optional class name of a registered runtime-UX driver component (a BaseEntityActionRuntimeUX subclass resolved via MJGlobal.ClassFactory) that owns this invocation's interaction — parameter collection, dry-run preview, confirmation, and progress. NULL invokes the action directly with no custom UX. This lets any action opt into a richer, reusable runtime experience while the grid/toolbar stays operation-agnostic.`}) 
+    @MaxLength(255)
+    RuntimeUXDriverClass?: string;
+        
     @Field() 
     @MaxLength(425)
     EntityAction: string;
@@ -45303,6 +45307,9 @@ export class CreateMJEntityActionInvocationInput {
     @Field({ nullable: true })
     Status?: string;
 
+    @Field({ nullable: true })
+    RuntimeUXDriverClass: string | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -45325,6 +45332,9 @@ export class UpdateMJEntityActionInvocationInput {
     @Field({ nullable: true })
     Status?: string;
 
+    @Field({ nullable: true })
+    RuntimeUXDriverClass?: string | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -60698,6 +60708,10 @@ export class MJOpenApp_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field({nullable: true, description: `In-repo subdirectory the app was installed from for multi-app repositories (e.g. 'CRM/HubSpot'). NULL when the app's mj-app.json is at the repository root.`}) 
+    @MaxLength(500)
+    Subpath?: string;
+        
     @Field() 
     @MaxLength(100)
     InstalledByUser: string;
@@ -60772,6 +60786,9 @@ export class CreateMJOpenAppInput {
     @Field({ nullable: true })
     Status?: string;
 
+    @Field({ nullable: true })
+    Subpath: string | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -60836,6 +60853,9 @@ export class UpdateMJOpenAppInput {
     @Field({ nullable: true })
     Status?: string;
 
+    @Field({ nullable: true })
+    Subpath?: string | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -62039,6 +62059,9 @@ export class MJProcessRun_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field(() => Boolean, {description: `When 1, this run was a dry-run (compute-only) preview: the per-record diffs were computed and persisted as Process Run Details, but no changes were written back to the target records. When 0, the run applied its changes.`}) 
+    DryRun: boolean;
+        
     @Field({nullable: true}) 
     @MaxLength(255)
     RecordProcess?: string;
@@ -62134,6 +62157,9 @@ export class CreateMJProcessRunInput {
     @Field({ nullable: true })
     StartedByUserID: string | null;
 
+    @Field(() => Boolean, { nullable: true })
+    DryRun?: boolean;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -62213,6 +62239,9 @@ export class UpdateMJProcessRunInput {
     @Field({ nullable: true })
     StartedByUserID?: string | null;
 
+    @Field(() => Boolean, { nullable: true })
+    DryRun?: boolean;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -68054,6 +68083,9 @@ export class MJRecordProcess_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field({nullable: true, description: `JSON configuration for the process's work, used by work types that need structured config beyond Input/Output mappings. For WorkType='FieldRules' this holds the serialized FieldRuleSet (the rules applied to each record). NULL for work types that do not use it.`}) 
+    Configuration?: string;
+        
     @Field({nullable: true}) 
     @MaxLength(255)
     Category?: string;
@@ -68176,6 +68208,9 @@ export class CreateMJRecordProcessInput {
     @Field(() => Int, { nullable: true })
     MaxConcurrency?: number | null;
 
+    @Field({ nullable: true })
+    Configuration: string | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -68267,6 +68302,9 @@ export class UpdateMJRecordProcessInput {
     @Field(() => Int, { nullable: true })
     MaxConcurrency?: number | null;
 
+    @Field({ nullable: true })
+    Configuration?: string | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -68670,6 +68708,15 @@ export class MJRemoteOperation_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field(() => Boolean, {description: `When 1, the AI-generated Code is frozen and Save() will not regenerate it even if Description changes (the Generated-Actions CodeLocked analog). Default 0.`}) 
+    CodeLocked: boolean;
+        
+    @Field({nullable: true, description: `The model's explanation / comments for the AI-generated Code (populated alongside Code when GenerationType=AI). Human-facing review aid.`}) 
+    CodeComments?: string;
+        
+    @Field({nullable: true, description: `JSON array of the libraries the generated body imports: [{ "Library": "@memberjunction/ai-prompts", "ItemsUsed": ["AIPromptRunner"] }, ...]. Bound to the RemoteOperationLibrary JSONType via metadata sync so CodeGen emits a typed LibrariesObject accessor; CodeGen uses it to emit the imports at the top of the generated remote_operations.ts. NULL/empty = only the default always-available libraries are imported.`}) 
+    Libraries?: string;
+        
     @Field({nullable: true}) 
     @MaxLength(255)
     Category?: string;
@@ -68757,6 +68804,15 @@ export class CreateMJRemoteOperationInput {
     @Field(() => Int, { nullable: true })
     MaxConcurrency: number | null;
 
+    @Field(() => Boolean, { nullable: true })
+    CodeLocked?: boolean;
+
+    @Field({ nullable: true })
+    CodeComments: string | null;
+
+    @Field({ nullable: true })
+    Libraries: string | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -68839,6 +68895,15 @@ export class UpdateMJRemoteOperationInput {
     @Field(() => Int, { nullable: true })
     MaxConcurrency?: number | null;
 
+    @Field(() => Boolean, { nullable: true })
+    CodeLocked?: boolean;
+
+    @Field({ nullable: true })
+    CodeComments?: string | null;
+
+    @Field({ nullable: true })
+    Libraries?: string | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 

package/src/index.ts

@@ -863,7 +863,11 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       onConnect: async (ctx) => {
         try {
           const token = String(ctx.connectionParams?.Authorization);
-          const userPayload = await getUserPayload(token, undefined, dataSources);
+          // Carry API keys from connectionParams so API-key / MCP / Node clients can authenticate the socket
+          // (validated the same way as the HTTP x-mj-api-key / x-mj-user-api-key headers).
+          const systemApiKey = ctx.connectionParams?.['x-mj-api-key'] ? String(ctx.connectionParams['x-mj-api-key']) : undefined;
+          const userApiKey = ctx.connectionParams?.['x-mj-user-api-key'] ? String(ctx.connectionParams['x-mj-user-api-key']) : undefined;
+          const userPayload = await getUserPayload(token, undefined, dataSources, undefined, systemApiKey, userApiKey);
 
           // Store validated payload on the connection for use in context()
           ctx.extra.userPayload = userPayload;

package/src/resolvers/ExecuteRemoteOperationResolver.ts

@@ -1,10 +1,14 @@
-import { Arg, Ctx, Field, InputType, Mutation, ObjectType, Resolver } from 'type-graphql';
+import { Arg, Ctx, Field, ID, InputType, Mutation, ObjectType, PubSub, PubSubEngine, Resolver, Root, Subscription } from 'type-graphql';
 import { MJGlobal } from '@memberjunction/global';
-import { BaseRemotableOperation, RemoteOpInvokeMode } from '@memberjunction/core';
+import { BaseRemotableOperation, RemoteOpInvokeMode, RemoteOpProgress } from '@memberjunction/core';
+import { RemoteOperationEngineBase } from '@memberjunction/core-entities';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { AppContext } from '../types.js';
 import { GetReadWriteProvider } from '../util.js';
 
+/** PubSub topic carrying RemoteOpProgress envelopes for attached over-the-wire callers (RO-3). */
+const REMOTE_OP_PROGRESS_TOPIC = 'RemoteOperationProgress';
+
 /** Input for the generic Remote Operation transport mutation. */
 @InputType()
 export class ExecuteRemoteOperationInput {
@@ -16,6 +20,25 @@ export class ExecuteRemoteOperationInput {
 
     @Field()
     invokeMode: string;
+
+    /**
+     * Optional client-generated channel id. When set (attached mode over the wire), the server publishes every
+     * `RemoteOpProgress` the operation emits to the `RemoteOperationProgress` subscription filtered by this id,
+     * so the caller's `onProgress` fires live while the operation runs. Omitted for sync / no-progress calls.
+     */
+    @Field(() => String, { nullable: true })
+    progressChannelId?: string;
+}
+
+/** A single streamed progress envelope delivered over the `RemoteOperationProgress` subscription. */
+@ObjectType()
+export class RemoteOperationProgressNotification {
+    @Field()
+    ChannelId: string;
+
+    /** JSON-serialized {@link RemoteOpProgress}. */
+    @Field()
+    ProgressJSON: string;
 }
 
 /** Result of the generic Remote Operation transport mutation. */
@@ -50,6 +73,7 @@ export class ExecuteRemoteOperationResolver extends ResolverBase {
     async ExecuteRemoteOperation(
         @Arg('input') input: ExecuteRemoteOperationInput,
         @Ctx() ctx: AppContext,
+        @PubSub() pubSub: PubSubEngine,
     ): Promise<ExecuteRemoteOperationResultType> {
         try {
             const key = input.operationKey?.trim();
@@ -78,6 +102,15 @@ export class ExecuteRemoteOperationResolver extends ResolverBase {
                 return fail('NO_USER', 'Not authenticated');
             }
 
+            // (4) Metadata gate (defense-in-depth): honor the op's MJ: Remote Operations Status/approval, so a
+            // registered-but-disabled (or unapproved AI) op is rejected even though its class is still in code.
+            const provider = GetReadWriteProvider(ctx.providers);
+            await RemoteOperationEngineBase.Instance.Config(false, user, provider);
+            const invokability = RemoteOperationEngineBase.Instance.IsInvokable(key);
+            if (!invokability.Invokable) {
+                return fail(invokability.ResultCode ?? 'OPERATION_UNAVAILABLE', invokability.Reason ?? `Operation '${key}' is unavailable`);
+            }
+
             let parsedInput: unknown;
             try {
                 parsedInput = input.inputJSON ? JSON.parse(input.inputJSON) : {};
@@ -85,9 +118,16 @@ export class ExecuteRemoteOperationResolver extends ResolverBase {
                 return fail('INVALID_INPUT_JSON', `Invalid input JSON: ${e instanceof Error ? e.message : String(e)}`);
             }
 
+            // Attached over-the-wire (RO-3): forward each emitted RemoteOpProgress to the progress channel so a
+            // remote caller's onProgress fires live. No-op when the caller didn't open a channel (sync calls).
+            const onProgress = input.progressChannelId
+                ? (p: RemoteOpProgress) => {
+                      void pubSub.publish(REMOTE_OP_PROGRESS_TOPIC, { ChannelId: input.progressChannelId!, ProgressJSON: JSON.stringify(p) });
+                  }
+                : undefined;
+
             // Route through the per-request provider (server in-process path; runs the op's Authorize + InternalExecute).
-            const provider = GetReadWriteProvider(ctx.providers);
-            const result = await provider.RouteOperation(key, parsedInput, { user, mode: input.invokeMode as RemoteOpInvokeMode });
+            const result = await provider.RouteOperation(key, parsedInput, { user, mode: input.invokeMode as RemoteOpInvokeMode, onProgress });
 
             return {
                 success: result.Success,
@@ -100,6 +140,22 @@ export class ExecuteRemoteOperationResolver extends ResolverBase {
             return fail('ERROR', e instanceof Error ? e.message : String(e));
         }
     }
+
+    /**
+     * Subscription the client opens (with a self-generated `channelId`) immediately before calling
+     * `ExecuteRemoteOperation` with the same id in `progressChannelId`. The server publishes one event per
+     * `RemoteOpProgress` the operation emits; filtered by `channelId` so concurrent calls never interleave.
+     */
+    @Subscription(() => RemoteOperationProgressNotification, {
+        topics: REMOTE_OP_PROGRESS_TOPIC,
+        filter: ({ payload, args }: { payload: RemoteOperationProgressNotification; args: { channelId: string } }) => payload.ChannelId === args.channelId,
+    })
+    RemoteOperationProgress(
+        @Root() notification: RemoteOperationProgressNotification,
+        @Arg('channelId', () => ID) _channelId: string,
+    ): RemoteOperationProgressNotification {
+        return notification;
+    }
 }
 
 /** Builds a failed result. */

package/src/resolvers/IntegrationDiscoveryResolver.ts

@@ -1,5 +1,5 @@
 import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType, Int, Float } from "type-graphql";
-import { CompositeKey, DatabaseProviderBase, LocalCacheManager, Metadata, RunView, UserInfo, LogError, LogStatus, IMetadataProvider, TransactionGroupBase } from "@memberjunction/core";
+import { CompositeKey, DatabaseProviderBase, EntityInfo, LocalCacheManager, Metadata, RunView, UserInfo, LogError, LogStatus, IMetadataProvider, TransactionGroupBase } from "@memberjunction/core";
 import { GetReadOnlyProvider, GetReadWriteProvider } from "../util.js";
 import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
 import {
@@ -3451,9 +3451,29 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
     ): Promise<ApplyAllEntityMapCreated[]> {
         const results: ApplyAllEntityMapCreated[] = [];
 
+        // PERF (large-catalog ApplyAll, e.g. Salesforce 1695 objects): precompute O(1) lookups ONCE before
+        // the per-object loop. The per-object path previously did an O(N) `provider.Entities.find` + a
+        // BypassCache RunView for the existing entity map PER object → O(N²) scans + N DB round-trips, so a
+        // 1695-object connector burned its whole budget in ApplyAll and FullSync never started. One entity
+        // index + one batched entity-map query make both O(1) per object.
+        const entityByKey = new Map(
+            provider.Entities.map(e => [`${e.SchemaName.toLowerCase()}|${e.BaseTable.toLowerCase()}`, e] as const)
+        );
+        const existingMapByExternalName = new Map<string, MJCompanyIntegrationEntityMapEntity>();
+        const allMaps = await new RunView().RunView<MJCompanyIntegrationEntityMapEntity>({
+            EntityName: 'MJ: Company Integration Entity Maps',
+            ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+            ResultType: 'entity_object',
+            BypassCache: true, // idempotency must read COMMITTED state, not a possibly-stale filtered cache
+        }, user);
+        if (allMaps.Success) {
+            for (const m of allMaps.Results) existingMapByExternalName.set((m.ExternalObjectName ?? '').toLowerCase(), m);
+        }
+
         for (const obj of objects) {
             const entityMapResult = await this.createSingleEntityMap(
-                companyIntegrationID, obj, connector, companyIntegration, schemaName, user, provider, defaultSyncDirection
+                companyIntegrationID, obj, connector, companyIntegration, schemaName, user, provider, defaultSyncDirection,
+                entityByKey, existingMapByExternalName
             );
             if (entityMapResult) {
                 results.push(entityMapResult);
@@ -3471,10 +3491,14 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         schemaName: string,
         user: UserInfo,
         md: IMetadataProvider,
-        defaultSyncDirection: string = 'Pull'
+        defaultSyncDirection: string = 'Pull',
+        entityByKey?: Map<string, EntityInfo>,
+        existingMapByExternalName?: Map<string, MJCompanyIntegrationEntityMapEntity>
     ): Promise<ApplyAllEntityMapCreated | null> {
-        // Find the entity by schema + table name
-        const entityInfo = md.Entities.find(
+        // Find the entity by schema + table name. PERF: O(1) precomputed index when provided
+        // (large-catalog ApplyAll); falls back to the O(N) scan when called without it.
+        const entityInfo = entityByKey?.get(`${schemaName.toLowerCase()}|${obj.TableName.toLowerCase()}`)
+          ?? md.Entities.find(
             e => e.SchemaName.toLowerCase() === schemaName.toLowerCase()
               && e.BaseTable.toLowerCase() === obj.TableName.toLowerCase()
         );
@@ -3488,19 +3512,27 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         // multiplies the maps in lockstep (N applies → N duplicate maps per object), which
         // silently corrupts the record-map 1:1 completeness gate and makes the forward sync
         // process each object N times. Reuse the existing (connection, external object) map instead.
-        const escapedObjectName = obj.SourceObjectName.replace(/'/g, "''");
-        const existingMapResult = await new RunView().RunView<MJCompanyIntegrationEntityMapEntity>({
-            EntityName: 'MJ: Company Integration Entity Maps',
-            ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND ExternalObjectName='${escapedObjectName}'`,
-            OrderBy: '__mj_CreatedAt ASC',
-            MaxRows: 1,
-            ResultType: 'entity_object',
-            BypassCache: true, // idempotency must read COMMITTED state, not a possibly-stale filtered cache
-        }, user);
+        // PERF: use the precomputed existing-map index when provided (one batched query for the whole
+        // ApplyAll instead of one BypassCache RunView per object); falls back to a per-object query.
+        let existing: MJCompanyIntegrationEntityMapEntity | undefined;
+        if (existingMapByExternalName) {
+            existing = existingMapByExternalName.get(obj.SourceObjectName.toLowerCase());
+        } else {
+            const escapedObjectName = obj.SourceObjectName.replace(/'/g, "''");
+            const existingMapResult = await new RunView().RunView<MJCompanyIntegrationEntityMapEntity>({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND ExternalObjectName='${escapedObjectName}'`,
+                OrderBy: '__mj_CreatedAt ASC',
+                MaxRows: 1,
+                ResultType: 'entity_object',
+                BypassCache: true, // idempotency must read COMMITTED state, not a possibly-stale filtered cache
+            }, user);
+            if (existingMapResult.Success && existingMapResult.Results.length > 0) existing = existingMapResult.Results[0];
+        }
 
         let em: MJCompanyIntegrationEntityMapEntity;
-        if (existingMapResult.Success && existingMapResult.Results.length > 0) {
-            em = existingMapResult.Results[0]; // reuse — keeps the map stable across re-applies
+        if (existing) {
+            em = existing; // reuse — keeps the map stable across re-applies
         } else {
             em = await md.GetEntityObject<MJCompanyIntegrationEntityMapEntity>('MJ: Company Integration Entity Maps', user);
             em.NewRecord();
@@ -3634,26 +3666,70 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
      * still surfaces every object/field; only materialization is capped. Per-table column count = the selected
      * field subset, or the object's full discovered field count when all fields are selected.
      */
-    private enforceSchemaLimits(
+    private async enforceSchemaLimits(
         objects: SchemaPreviewObjectInput[],
         filteredSchema: SourceSchemaInfo,
-    ): void {
-        const envInt = (name: string): number | null => {
-            const v = parseInt(process.env[name] ?? '', 10);
-            return Number.isFinite(v) && v > 0 ? v : null;
-        };
+        companyIntegration: MJCompanyIntegrationEntity,
+        user: UserInfo,
+        md: IMetadataProvider,
+    ): Promise<string[]> {
+        const warnings: string[] = [];
         const fullCountByName = new Map(filteredSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.Fields.length]));
-        // Delegate the cap decision to the engine's pure, unit-tested decideSchemaLimitViolations.
+        // Use the MAX of the input object's Fields and the filtered-schema count — the batch path can pass
+        // objects with empty Fields (the real columns come from filteredSchema, which is what buildSchema
+        // materializes). `?? ` would wrongly read an empty [] as 0 (0 is not nullish); Math.max is robust to
+        // either source being empty and reflects the count that will actually become columns.
+        const colCount = (o: SchemaPreviewObjectInput): number =>
+            Math.max(fullCountByName.get(o.SourceObjectName.toLowerCase()) ?? 0, o.Fields?.length ?? 0);
+
+        // ── Per-table COLUMN limit: DISABLE-the-offender, NOT reject-the-apply. The limit is clamped at
+        // startup to ≤ IntegrationEngine.MAX_COLUMNS_CEILING (SQL Server's 1024 minus framework column
+        // headroom). An object exceeding it is set Status='Disabled' (reversible — it re-enables on a later
+        // discovery if it has shrunk back under the limit) and dropped from THIS apply, so the materializable
+        // objects still sync instead of the whole apply failing CREATE TABLE. One CLI warning per disabled object.
+        const limit = IntegrationEngine.Instance.MaxColumnsPerTable;
+        const overLimit = objects.filter(o => colCount(o) > limit);
+        if (overLimit.length > 0) {
+            const ioIDByName = new Map(
+                IntegrationEngineBase.Instance.GetActiveIntegrationObjects(companyIntegration.IntegrationID)
+                    .map(io => [io.Name.toLowerCase(), io.ID] as [string, string])
+            );
+            for (const o of overLimit) {
+                warnings.push(`Disabled "${o.SourceObjectName}" (${colCount(o)} columns > limit ${limit}) — too wide to materialize as one table; reduce its columns or it stays disabled.`);
+                const ioID = ioIDByName.get(o.SourceObjectName.toLowerCase());
+                if (ioID) {
+                    const io = await md.GetEntityObject<MJIntegrationObjectEntity>('MJ: Integration Objects', user);
+                    if (await io.Load(ioID)) {
+                        io.Status = 'Disabled';
+                        if (!await io.Save()) {
+                            LogError(`enforceSchemaLimits: failed to disable over-wide IO '${o.SourceObjectName}': ${io.LatestResult?.CompleteMessage ?? 'unknown error'}`);
+                        }
+                    }
+                }
+            }
+            // Drop the disabled objects from BOTH the shared objects array (used downstream by
+            // buildTargetConfigs + createEntityAndFieldMaps) and filteredSchema, in place.
+            const disabled = new Set(overLimit.map(o => o.SourceObjectName.toLowerCase()));
+            for (let i = objects.length - 1; i >= 0; i--) {
+                if (disabled.has(objects[i].SourceObjectName.toLowerCase())) objects.splice(i, 1);
+            }
+            filteredSchema.Objects = filteredSchema.Objects.filter(o => !disabled.has(o.ExternalName.toLowerCase()));
+        }
+
+        // MaxTables remains an operator/env REJECT guardrail (unchanged), evaluated on the surviving objects.
+        // Columns are handled above via disable, so the pure decision is asked about tables only here.
+        const maxTables = ((): number | null => {
+            const v = parseInt(process.env.MJ_INTEGRATION_MAX_TABLES ?? '', 10);
+            return Number.isFinite(v) && v > 0 ? v : null;
+        })();
         const violations = decideSchemaLimitViolations({
             TableCount: objects.length,
-            ColumnCountByTable: objects.map(o => ({
-                Name: o.SourceObjectName,
-                ColumnCount: o.Fields?.length ?? fullCountByName.get(o.SourceObjectName.toLowerCase()) ?? 0,
-            })),
-            MaxTables: envInt('MJ_INTEGRATION_MAX_TABLES'),
-            MaxColumnsPerTable: envInt('MJ_INTEGRATION_MAX_COLUMNS_PER_TABLE'),
+            ColumnCountByTable: [],
+            MaxTables: maxTables,
+            MaxColumnsPerTable: null,
         });
         if (violations.length > 0) throw new Error(violations.join(' '));
+        return warnings;
     }
 
     private async buildSchemaForConnector(
@@ -3717,7 +3793,7 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         // §B — reject an over-limit table/column SELECTION before ANY table is materialized. This is the
         // single shared gate for ApplyAll / ApplyAllBatch / ApplySchemaBatch (all route through here).
         // Caps are operator/env guardrails (MJ_INTEGRATION_MAX_TABLES / _MAX_COLUMNS_PER_TABLE).
-        this.enforceSchemaLimits(objects, filteredSchema);
+        const limitWarnings = await this.enforceSchemaLimits(objects, filteredSchema, companyIntegration, user, provider);
 
         const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, platform, connector);
 
@@ -3736,6 +3812,8 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
 
         const builder = new SchemaBuilder();
         const schemaOutput = builder.BuildSchema(input);
+        // Surface the auto-disabled over-wide objects (if any) in the apply's Warnings → CLI output.
+        if (limitWarnings.length > 0) schemaOutput.Warnings.unshift(...limitWarnings);
 
         if (schemaOutput.Errors.length > 0) {
             throw new Error(`Schema generation failed: ${schemaOutput.Errors.join('; ')}`);

package/src/resolvers/RealtimeBridgeResolver.ts

@@ -1,11 +1,11 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, InputType, Field } from 'type-graphql';
 import { randomUUID } from 'crypto';
-import { LogError, UserInfo, IMetadataProvider } from '@memberjunction/core';
+import { LogError, LogStatusEx, UserInfo, IMetadataProvider } from '@memberjunction/core';
 import { LiveKitTokenService, LiveKitAgentRoomCoordinator, LiveKitEgressService } from '@memberjunction/livekit-room-server';
 import { AppContext } from '../types.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadWriteProvider } from '../util.js';
-import { CreateBridgeRealtimeSession, FinalizeBridgeCoAgentRuns, GetRealtimeModelVoices, CreateBridgeRoomTranscriptSink } from '@memberjunction/ai-agents';
+import { CreateBridgeRealtimeSession, FinalizeBridgeCoAgentRuns, GetRealtimeModelVoices, CreateBridgeRoomTranscriptSink, RealtimeTurnModeratorDecision } from '@memberjunction/ai-agents';
 import { AIBridgeEngine } from '@memberjunction/ai-bridge-server';
 import { SessionManager } from '../agentSessions/SessionManager.js';
 import { NotificationEngine } from '@memberjunction/notifications';
@@ -36,9 +36,25 @@ AIBridgeEngine.Instance.SetSessionRunFinalizer(FinalizeBridgeCoAgentRuns);
  * "Meeting Room"/scope choices live HERE (the Meet composition layer), keeping the engine generic.
  */
 AIBridgeEngine.Instance.SetTranscriptSink(
-  CreateBridgeRoomTranscriptSink({ ConversationType: 'Meeting Room', ApplicationScope: 'Application' }),
+  CreateBridgeRoomTranscriptSink({ ConversationType: 'Meeting Room', ApplicationScope: 'Application', ApplicationName: 'Meet' }),
 );
 
+/**
+ * Binds the room **turn moderator** onto the bridge engine — **OPT-IN, off by default**. When
+ * `MJ_REALTIME_MODERATOR_MODE=on`, a multi-agent room routes each turn through a fast LLM prompt that decides
+ * who speaks (see `RealtimeTurnModerator` in `@memberjunction/ai-agents`). By default it's OFF: agents run in
+ * plain auto-response, hear everything, and self-moderate (no STT-driven router in the loop) — the
+ * coordinator likewise skips meeting mode when the flag is off, so the two stay consistent. We keep the
+ * moderator wired-but-toggleable for controlled scenarios (webinars, large rooms, weaker models).
+ */
+if (process.env.MJ_REALTIME_MODERATOR_MODE === 'on') {
+  AIBridgeEngine.Instance.SetTurnModerator(RealtimeTurnModeratorDecision);
+  console.log('[RealtimeBridge] turn MODERATOR mode is ON (MJ_REALTIME_MODERATOR_MODE=on) — multi-agent rooms use the LLM router.');
+} else {
+  // Default mode — only surface this at startup when verbose (MJ_VERBOSE) is on; it's the expected state and otherwise just noise.
+  LogStatusEx({ message: '[RealtimeBridge] turn moderator mode is OFF (default) — multi-agent rooms run free-for-all: all agents auto-respond + hear everything.', verboseOnly: true });
+}
+
 /**
  * GraphQL surface for the MJ-native LiveKit room: mints scoped client access tokens and starts an
  * agent's presence in a room. The thin resolver delegates to `@memberjunction/livekit-room-server`
@@ -319,6 +335,33 @@ export class RealtimeBridgeResolver extends ResolverBase {
     }
   }
 
+  /**
+   * **Ends the meeting for everyone**: stops EVERY agent bot bridged into a room (by room name, via the
+   * coordinator's server-side roster). This is the "End meeting" half of the Zoom-style leave control —
+   * usable by any participant, including one who only *joined* the room and never tracked the bridge ids.
+   * Returns `true` when the teardown ran (even if the room held zero agents). Best-effort: any error → `false`.
+   *
+   * @param roomName The LiveKit room to end.
+   */
+  @Mutation(() => Boolean)
+  async EndLiveKitRoom(
+    @Arg('roomName', () => String) roomName: string,
+    @Ctx() context: AppContext = {} as AppContext,
+  ): Promise<boolean> {
+    try {
+      const user = this.GetUserFromPayload(context.userPayload);
+      if (!user) {
+        return false;
+      }
+      const provider = GetReadWriteProvider(context.providers) as unknown as IMetadataProvider;
+      await LiveKitAgentRoomCoordinator.Instance.StopAllAgentsInRoom(roomName, 'Explicit', user, provider);
+      return true;
+    } catch (error) {
+      LogError(`EndLiveKitRoom failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+
   /**
    * Lists active Realtime models with the voices each driver supports — the source for the dev model/voice
    * picker (gated client-side by the `Realtime: Advanced Session Controls` authorization). Read-only; returns

package/src/resolvers/RunTemplateResolver.ts

@@ -21,8 +21,16 @@ export class TemplateRunResult {
     executionTimeMs?: number;
 }
 
+/**
+ * @deprecated Prefer the `Template.Run` Remote Operation (`@memberjunction/templates-base-types`
+ * `TemplateRunOperation`) — one typed call site that routes over the generic `ExecuteRemoteOperation`
+ * transport on the client and in-process on the server. This bespoke `RunTemplate` mutation is retained
+ * only for backward compatibility with existing external API consumers and may be removed in a future
+ * major version.
+ */
 @Resolver()
 export class RunTemplateResolver extends ResolverBase {
+    /** @deprecated Use the `Template.Run` Remote Operation instead. Retained for backcompat. */
     @Mutation(() => TemplateRunResult)
     async RunTemplate(
         @Arg('templateId') templateId: string,