@memberjunction/codegen-lib 6.1.4 → 6.2.0-edge.1

package/dist/Database/manage-metadata.js

@@ -1,53 +1,54 @@
 import { SQLServerDialect, PostgreSQLDialect } from '@memberjunction/sql-dialect';
 import { CodeGenDatabaseProvider } from './codeGenDatabaseProvider.js';
-import { analyzeQueryForMaterialization, detectAggregationKeyColumns, detectAdditiveMeasures, MATERIALIZATION_SURROGATE_COLUMN } from './materializationAnalysis.js';
-import { evaluateMaterializationDrift } from './materializationDrift.js';
-import { classifyQueryParameters, buildHeldValues } from './materializationParamClassifier.js';
-import { buildBroadRowFilterSQL } from './materializationBroadRender.js';
+import { AnalyzeQueryForMaterialization, DetectAggregationKeyColumns, DetectAdditiveMeasures, MATERIALIZATION_SURROGATE_COLUMN } from './materializationAnalysis.js';
+import { EvaluateMaterializationDrift } from './materializationDrift.js';
+import { ClassifyQueryParameters, BuildHeldValues } from './materializationParamClassifier.js';
+import { BuildBroadRowFilterSQL } from './materializationBroadRender.js';
 import { QueryParameterProcessor } from '@memberjunction/query-processor';
 // Side-effect import — registers `SQLServerCodeGenProvider` with `MJGlobal.ClassFactory`
 // under the `'sqlserver'` key via its `@RegisterClass` decorator. Without this import,
 // `ClassFactory.CreateInstance(CodeGenDatabaseProvider, 'sqlserver')` returns nothing
 // and the SS code path silently fails.
 import './providers/sqlserver/SQLServerCodeGenProvider.js';
-import { configInfo, currentWorkingDirectory, dbPlatform, getSettingValue, mj_core_schema, outputDir } from '../Config/config.js';
+import { configInfo, currentWorkingDirectory, DbPlatform, GetSettingValue, MjCoreSchema, OutputDir } from '../Config/config.js';
 import { CodeNameFromString, EntityFieldInfo, EntityInfo, ExternalDataSourceReadRouter, ExtractActualDefaultValue, LogError, LogStatus, Metadata, RunQuerySQLFilterManager, SeverityType } from "@memberjunction/core";
 import { MJEntityFieldSchema } from "@memberjunction/core-entities";
-import { logError, logMessage, logStatus, startSpinner, updateSpinner, succeedSpinner } from "../Misc/status_logging.js";
+import { logError, LogMessage, logStatus, StartSpinner, UpdateSpinner, SucceedSpinner } from "../Misc/status_logging.js";
 import { SQLUtilityBase } from "./sql.js";
-import { applyIncludeSchemaScope } from "./schema-scope.js";
-import { buildHealSchemaRoutineParams, getAuthoredExcludeSchemas, snapshotAuthoredExcludeSchemas } from "./heal-schema-params.js";
-import { AdvancedGeneration, isPlausibleEntityName } from "../Misc/advanced_generation.js";
+import { ApplyIncludeSchemaScope } from "./schema-scope.js";
+import { BuildHealSchemaRoutineParams, GetAuthoredExcludeSchemas, SnapshotAuthoredExcludeSchemas } from "./heal-schema-params.js";
+import { AdvancedGeneration, IsPlausibleEntityName } from "../Misc/advanced_generation.js";
 import { CodeGenReporter } from "../Misc/codegen-reporter.js";
-import { applySearchableFieldsCap, entityLevelEnableBlockedReason, isNarrativeFieldName, normalizePredicate, normalizeSmartFieldResultShape, } from "./search-guardrails.js";
-import { mapExternalNativeTypeToMJ } from "../Misc/externalTypeMapping.js";
+import { ApplySearchableFieldsCap, DefaultPredicateFor, EntityLevelEnableBlockedReason, IsNarrativeFieldName, MAX_SEARCHABLE_FIELDS_PER_ENTITY, NAME_LIKE_FIELD_NAMES, NormalizePredicate, NormalizeSmartFieldResultShape, } from "./search-guardrails.js";
+import { MapExternalNativeTypeToMJ } from "../Misc/externalTypeMapping.js";
 import { SQLParser } from "@memberjunction/sql-parser";
 import { createDisplayName, generatePluralName, MJGlobal, ResolveSingleEntityResourceTarget, stripTrailingChars, UUIDsEqual } from "@memberjunction/global";
 import { v4 as uuidv4, v5 as uuidv5 } from 'uuid';
 import * as fs from 'fs';
 import path from 'path';
-import { canonicalJSONStringify, deepEqualJSON } from "../Misc/util.js";
+import { CanonicalJSONStringify, DeepEqualJSON } from "../Misc/util.js";
+import { TrimTrailingStatementTerminators } from "../Misc/sql_text.js";
 import { SQLLogging } from "../Misc/sql_logging.js";
-import { computeFieldMetadataUpdate } from "./field-metadata-lock.js";
+import { ComputeFieldMetadataUpdate } from "./field-metadata-lock.js";
 import { TRACKED_FIELD_COLUMNS, DISPLAYNAME_REOPEN_REASONS, TYPE_REOPEN_REASONS, diffEntityFieldSnapshots, } from './entity-field-change-tracking.js';
-export { TRACKED_FIELD_COLUMNS, DISPLAYNAME_REOPEN_REASONS, TYPE_REOPEN_REASONS, diffEntityFieldSnapshots, } from './entity-field-change-tracking.js';
+export { TRACKED_FIELD_COLUMNS, DISPLAYNAME_REOPEN_REASONS, TYPE_REOPEN_REASONS, DiffEntityFieldSnapshots, diffEntityFieldSnapshots, } from './entity-field-change-tracking.js';
 export class ValidatorResult {
     constructor() {
-        this.entityName = "";
-        this.sourceCheckConstraint = "";
-        this.functionText = "";
-        this.functionName = "";
-        this.functionDescription = "";
+        this.entityName = ""; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+        this.sourceCheckConstraint = ""; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+        this.functionText = ""; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+        this.functionName = ""; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+        this.functionDescription = ""; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
         /**
          * The ID value in the Generated Codes entity that was created for this validator.
          */
-        this.generatedCodeId = "";
+        this.generatedCodeId = ""; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
         /**
          * The ID for the AI Model that was used to generate the code
          */
-        this.aiModelID = "";
-        this.wasGenerated = true;
-        this.success = false;
+        this.aiModelID = ""; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+        this.wasGenerated = true; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+        this.success = false; // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
     }
 }
 export class ManageMetadataBase {
@@ -97,7 +98,7 @@ export class ManageMetadataBase {
      */
     get dbProvider() {
         if (!this._dbProvider) {
-            const platform = dbPlatform();
+            const platform = DbPlatform();
             const provider = MJGlobal.Instance.ClassFactory.CreateInstance(CodeGenDatabaseProvider, platform);
             // CreateInstance returns the abstract base class on a missed key (it
             // doesn't throw), so disambiguate by constructor identity: anything
@@ -190,7 +191,7 @@ export class ManageMetadataBase {
      */
     applyTimeEntityFieldSequenceSQL(entityID) {
         // COALESCE is valid on both platforms and is the form the docs and the gate describe.
-        return `(SELECT COALESCE(MAX(${this.qi('Sequence')}), 0) + 1 FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ${this.qi('EntityID')} = '${entityID}')`;
+        return `(SELECT COALESCE(MAX(${this.qi('Sequence')}), 0) + 1 FROM ${this.qs(MjCoreSchema(), 'EntityField')} WHERE ${this.qi('EntityID')} = '${entityID}')`;
     }
     /**
      * Wraps a SELECT query with a row limit.
@@ -212,7 +213,7 @@ export class ManageMetadataBase {
      * (avoids hardcoding runtime UUIDs that may differ on a fresh database).
      */
     entityIdSubquery(tableName, schemaName) {
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         return `(${this.selectTop(1, 'ID', `FROM ${this.qs(schema, 'vwEntities')} WHERE BaseTable = '${tableName}' AND SchemaName = '${schemaName}'`)})`;
     }
     /**
@@ -262,22 +263,38 @@ export class ManageMetadataBase {
     /**
      * Globally scoped list of entities that have been created during the metadata management process.
      */
-    static get newEntityList() {
+    static get NewEntityList() {
         return this._newEntityList;
     }
-    static set newEntityList(value) {
+    static set NewEntityList(value) {
         this._newEntityList = value;
     }
+    /** @deprecated Use {@link NewEntityList}. */
+    static get newEntityList() {
+        return this.NewEntityList;
+    }
+    /** @deprecated Use {@link NewEntityList}. */
+    static set newEntityList(value) {
+        this.NewEntityList = value;
+    }
     static { this._modifiedEntityList = []; }
     /**
      * Globally scoped list of entities that have been modified during the metadata management process.
      */
-    static get modifiedEntityList() {
+    static get ModifiedEntityList() {
         return this._modifiedEntityList;
     }
-    static set modifiedEntityList(value) {
+    static set ModifiedEntityList(value) {
         this._modifiedEntityList = value;
     }
+    /** @deprecated Use {@link ModifiedEntityList}. */
+    static get modifiedEntityList() {
+        return this.ModifiedEntityList;
+    }
+    /** @deprecated Use {@link ModifiedEntityList}. */
+    static set modifiedEntityList(value) {
+        this.ModifiedEntityList = value;
+    }
     static { this._newFieldSet = new Set(); }
     static { this._changedFields = new Map(); }
     static { this._changedFieldReport = []; }
@@ -289,13 +306,17 @@ export class ManageMetadataBase {
         }
         return `${eid}:${fld}`;
     }
-    static registerNewField(entityID, name) {
+    static RegisterNewField(entityID, name) {
         const key = this.fieldKey(entityID, name);
         if (key) {
             this._newFieldSet.add(key);
         }
     }
-    static registerFieldChange(entityID, name, reasons) {
+    /** @deprecated Use {@link RegisterNewField}. */
+    static registerNewField(entityID, name) {
+        return this.RegisterNewField(entityID, name);
+    }
+    static RegisterFieldChange(entityID, name, reasons) {
         const key = this.fieldKey(entityID, name);
         if (key) {
             let set = this._changedFields.get(key);
@@ -308,17 +329,29 @@ export class ManageMetadataBase {
             }
         }
     }
-    static isFieldNew(entityID, name) {
+    /** @deprecated Use {@link RegisterFieldChange}. */
+    static registerFieldChange(entityID, name, reasons) {
+        return this.RegisterFieldChange(entityID, name, reasons);
+    }
+    static IsFieldNew(entityID, name) {
         const key = this.fieldKey(entityID, name);
         return key ? this._newFieldSet.has(key) : false;
     }
-    static fieldChangeReasons(entityID, name) {
+    /** @deprecated Use {@link IsFieldNew}. */
+    static isFieldNew(entityID, name) {
+        return this.IsFieldNew(entityID, name);
+    }
+    static FieldChangeReasons(entityID, name) {
         const key = this.fieldKey(entityID, name);
         const set = key ? this._changedFields.get(key) : undefined;
         return set ?? new Set();
     }
-    static isDisplayNameReopened(entityID, name) {
-        const reasons = this.fieldChangeReasons(entityID, name);
+    /** @deprecated Use {@link FieldChangeReasons}. */
+    static fieldChangeReasons(entityID, name) {
+        return this.FieldChangeReasons(entityID, name);
+    }
+    static IsDisplayNameReopened(entityID, name) {
+        const reasons = this.FieldChangeReasons(entityID, name);
         for (const r of reasons) {
             if (DISPLAYNAME_REOPEN_REASONS.has(r)) {
                 return true;
@@ -326,8 +359,12 @@ export class ManageMetadataBase {
         }
         return false;
     }
-    static isTypeReopened(entityID, name) {
-        const reasons = this.fieldChangeReasons(entityID, name);
+    /** @deprecated Use {@link IsDisplayNameReopened}. */
+    static isDisplayNameReopened(entityID, name) {
+        return this.IsDisplayNameReopened(entityID, name);
+    }
+    static IsTypeReopened(entityID, name) {
+        const reasons = this.FieldChangeReasons(entityID, name);
         for (const r of reasons) {
             if (TYPE_REOPEN_REASONS.has(r)) {
                 return true;
@@ -335,20 +372,40 @@ export class ManageMetadataBase {
         }
         return false;
     }
-    static get newFieldCount() {
+    /** @deprecated Use {@link IsTypeReopened}. */
+    static isTypeReopened(entityID, name) {
+        return this.IsTypeReopened(entityID, name);
+    }
+    static get NewFieldCount() {
         return this._newFieldSet.size;
     }
-    static get changedFieldCount() {
+    /** @deprecated Use {@link NewFieldCount}. */
+    static get newFieldCount() {
+        return this.NewFieldCount;
+    }
+    static get ChangedFieldCount() {
         return this._changedFields.size;
     }
-    static get changedFieldReport() {
+    /** @deprecated Use {@link ChangedFieldCount}. */
+    static get changedFieldCount() {
+        return this.ChangedFieldCount;
+    }
+    static get ChangedFieldReport() {
         return this._changedFieldReport;
     }
-    static clearFieldTracking() {
+    /** @deprecated Use {@link ChangedFieldReport}. */
+    static get changedFieldReport() {
+        return this.ChangedFieldReport;
+    }
+    static ClearFieldTracking() {
         this._newFieldSet.clear();
         this._changedFields.clear();
         this._changedFieldReport = [];
     }
+    /** @deprecated Use {@link ClearFieldTracking}. */
+    static clearFieldTracking() {
+        return this.ClearFieldTracking();
+    }
     /**
      * Takes a snapshot of EntityField rows from vwEntityFields for diffing.
      * Only queries columns in TRACKED_FIELD_COLUMNS (Sequence is excluded).
@@ -360,7 +417,7 @@ export class ManageMetadataBase {
             : '';
         const cols = TRACKED_FIELD_COLUMNS.map(c => this.qi(c)).join(', ');
         const sSQL = `SELECT ${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('Entity')} AS ${this.qi('EntityName')}, ${this.qi('Name')}, ${cols}
-                    FROM ${this.qs(mj_core_schema(), 'vwEntityFields')}
+                    FROM ${this.qs(MjCoreSchema(), 'vwEntityFields')}
                     ${filter}`;
         const result = await this.runQuery(pool, sSQL);
         const map = new Map();
@@ -390,9 +447,13 @@ export class ManageMetadataBase {
      * the dead class keeps a live `@RegisterClass` registration on disk. The old monolith could
      * not drift this way: it was rewritten in full every run.
      */
-    static get deletedEntitySchemaList() {
+    static get DeletedEntitySchemaList() {
         return this._deletedEntitySchemaList;
     }
+    /** @deprecated Use {@link DeletedEntitySchemaList}. */
+    static get deletedEntitySchemaList() {
+        return this.DeletedEntitySchemaList;
+    }
     static { this._entitiesRequiringViewRegen = []; }
     /**
      * Entities that had late-phase changes requiring their base views to be
@@ -411,9 +472,13 @@ export class ManageMetadataBase {
     /**
      * Globally scoped list of validators that have been generated during the metadata management process.
      */
-    static get generatedValidators() {
+    static get GeneratedValidators() {
         return this._generatedValidators;
     }
+    /** @deprecated Use {@link GeneratedValidators}. */
+    static get generatedValidators() {
+        return this.GeneratedValidators;
+    }
     static { this._softPKFKConfigCache = null; }
     static { this._softPKFKConfigPath = ''; }
     /**
@@ -428,16 +493,20 @@ export class ManageMetadataBase {
      * Deterministic + event-driven (no mtime/TOCTOU race). The CLI `Run()` path does not call this, so its
      * load-once-per-process behavior is unchanged.
      */
-    static invalidateSoftPKFKConfigCache() {
+    static InvalidateSoftPKFKConfigCache() {
         ManageMetadataBase._softPKFKConfigCache = null;
         ManageMetadataBase._softPKFKConfigPath = '';
     }
+    /** @deprecated Use {@link InvalidateSoftPKFKConfigCache}. */
+    static invalidateSoftPKFKConfigCache() {
+        return this.InvalidateSoftPKFKConfigCache();
+    }
     /**
      * Loads and caches the soft PK/FK configuration from the additionalSchemaInfo file.
      * Cached per process to avoid repeated I/O within a CodeGen run; the in-process (RSU) path calls
      * {@link invalidateSoftPKFKConfigCache} at the start of each run so a rewritten file is picked up.
      */
-    static getSoftPKFKConfig() {
+    static GetSoftPKFKConfig() {
         // Return cached config if path hasn't changed
         const configPath = configInfo.additionalSchemaInfo
             ? path.join(currentWorkingDirectory, configInfo.additionalSchemaInfo)
@@ -463,6 +532,10 @@ export class ManageMetadataBase {
             return null;
         }
     }
+    /** @deprecated Use {@link GetSoftPKFKConfig}. */
+    static getSoftPKFKConfig() {
+        return this.GetSoftPKFKConfig();
+    }
     /**
      * Extracts a flat array of table configs from the config file, handling both formats:
      *   1. Schema-as-key (template format): { "dbo": [{ "TableName": "Orders", ... }] }
@@ -668,35 +741,47 @@ export class ManageMetadataBase {
     async processOrganicKeyConfig(pool) {
         const config = ManageMetadataBase.getSoftPKFKConfig();
         if (!config)
-            return { success: true, createdCount: 0, updatedCount: 0 };
+            return { success: true, createdCount: 0, updatedCount: 0, failedCount: 0 };
         const allOrganicKeys = this.extractOrganicKeysFromConfig(config);
         if (allOrganicKeys.length === 0)
-            return { success: true, createdCount: 0, updatedCount: 0 };
-        const schema = mj_core_schema();
+            return { success: true, createdCount: 0, updatedCount: 0, failedCount: 0 };
+        const schema = MjCoreSchema();
         let createdCount = 0;
         let updatedCount = 0;
+        let failedCount = 0;
         for (const tableConfig of allOrganicKeys) {
             // Resolve the owning entity
-            const ownerResult = await this.runQueryWithParams(pool, `
-            ${this.selectTop(1, 'ID, Name', `FROM ${this.qs(schema, 'vwEntities')}
-            WHERE (BaseTable = @TableName AND SchemaName = @SchemaName)
-               OR Name = @TableName`, 'CASE WHEN BaseTable = @TableName AND SchemaName = @SchemaName THEN 0 ELSE 1 END')}
-         `, { 'TableName': tableConfig.TableName, 'SchemaName': tableConfig.SchemaName });
-            if (ownerResult.recordset.length === 0) {
-                logError(`    > Organic keys config: entity "${tableConfig.SchemaName}.${tableConfig.TableName}" not found — skipping`);
+            const owner = await this.findOrganicKeyEntity(pool, tableConfig.SchemaName, tableConfig.TableName);
+            if (!owner) {
+                // Every key declared on this table goes unapplied, so each one counts as a failure.
+                failedCount += tableConfig.OrganicKeys.length;
+                logError(`    > Organic keys config: entity "${tableConfig.SchemaName}.${tableConfig.TableName}" not found — skipping its ${tableConfig.OrganicKeys.length} organic key(s)`);
                 continue;
             }
-            const ownerEntityId = ownerResult.recordset[0].ID;
-            const ownerEntityName = ownerResult.recordset[0].Name;
+            const ownerEntityId = owner.ID;
+            const ownerEntityName = owner.Name;
             for (const okConfig of tableConfig.OrganicKeys) {
                 try {
+                    // Resolve every related entity BEFORE writing anything for this key. Step 1 creates
+                    // bridge views (in the database and the migration log) and step 2 records the key, so
+                    // discovering a missing related entity in step 3 would leave an orphan view and a key
+                    // with a mapping missing.
+                    const relatedEntities = await this.resolveOrganicKeyRelatedEntities(pool, okConfig);
+                    if (!relatedEntities) {
+                        failedCount++;
+                        continue;
+                    }
                     // Step 1: Create transitive views if defined
                     for (const re of okConfig.RelatedEntities) {
                         if (re.TransitiveView) {
                             const viewSchema = re.TransitiveView.SchemaName || re.SchemaName;
                             const viewFullName = `${viewSchema}.${re.TransitiveView.Name}`;
-                            const viewSQL = `CREATE OR ALTER VIEW ${this.qs(viewSchema, re.TransitiveView.Name)} AS\n${re.TransitiveView.SQL}`;
-                            await this.LogSQLAndExecute(pool, viewSQL, `Create transitive bridge view ${viewFullName} for organic key "${okConfig.Name}" on ${ownerEntityName}`);
+                            const viewSQL = this.dbProvider.generateCreateOrReplaceViewSQL(viewSchema, re.TransitiveView.Name, re.TransitiveView.SQL);
+                            // T-SQL requires CREATE [OR ALTER] VIEW to be the ONLY statement in its batch — first as
+                            // well as last — and the metadata DML logged just before it (entity-config UPDATEs, the
+                            // previous key's INSERTs) has no trailing GO. requiresOwnBatch puts the provider's
+                            // separator on both sides in the migration file ('' on PostgreSQL: nothing is added).
+                            await this.logSQLAndExecute(pool, viewSQL, `Create transitive bridge view ${viewFullName} for organic key "${okConfig.Name}" on ${ownerEntityName}`, false, true, this.dbProvider.BatchSeparator, true);
                             // Auto-populate TransitiveObject from the view definition
                             re.TransitiveObject = viewFullName;
                         }
@@ -716,7 +801,7 @@ export class ManageMetadataBase {
                      Sequence = ${okConfig.Sequence ?? 0},
                      Status = 'Active'
                      WHERE ID = '${organicKeyId}'`;
-                        await this.LogSQLAndExecute(pool, updateSQL, `Update organic key "${okConfig.Name}" on ${ownerEntityName}`);
+                        await this.logSQLAndExecute(pool, updateSQL, `Update organic key "${okConfig.Name}" on ${ownerEntityName}`);
                         updatedCount++;
                         logStatus(`    > Organic key: Updated "${okConfig.Name}" on ${ownerEntityName}`);
                     }
@@ -726,7 +811,7 @@ export class ManageMetadataBase {
                         const insertSQL = `INSERT INTO ${this.qs(schema, 'EntityOrganicKey')}
                      (EntityID, Name, ${okConfig.Description ? 'Description, ' : ''}MatchFieldNames, NormalizationStrategy, ${okConfig.CustomNormalizationExpression ? 'CustomNormalizationExpression, ' : ''}Sequence, Status)
                      VALUES (${ownerSubquery}, '${okConfig.Name}', ${okConfig.Description ? `'${okConfig.Description.replace(/'/g, "''")}', ` : ''}'${matchFieldNames}', '${okConfig.NormalizationStrategy || 'LowerCaseTrim'}', ${okConfig.CustomNormalizationExpression ? `'${okConfig.CustomNormalizationExpression.replace(/'/g, "''")}', ` : ''}${okConfig.Sequence ?? 0}, 'Active')`;
-                        await this.LogSQLAndExecute(pool, insertSQL, `Insert organic key "${okConfig.Name}" on ${ownerEntityName}`);
+                        await this.logSQLAndExecute(pool, insertSQL, `Insert organic key "${okConfig.Name}" on ${ownerEntityName}`);
                         createdCount++;
                         logStatus(`    > Organic key: Created "${okConfig.Name}" on ${ownerEntityName}`);
                         // Fetch the new ID
@@ -734,18 +819,9 @@ export class ManageMetadataBase {
                         organicKeyId = newKey.recordset[0].ID;
                     }
                     // Step 3: Upsert EntityOrganicKeyRelatedEntity for each related entity
-                    for (const reConfig of okConfig.RelatedEntities) {
-                        const relResult = await this.runQueryWithParams(pool, `
-                     ${this.selectTop(1, 'ID, Name', `FROM ${this.qs(schema, 'vwEntities')}
-                     WHERE (BaseTable = @TableName AND SchemaName = @SchemaName)
-                        OR Name = @TableName`, 'CASE WHEN BaseTable = @TableName AND SchemaName = @SchemaName THEN 0 ELSE 1 END')}
-                  `, { 'TableName': reConfig.TableName, 'SchemaName': reConfig.SchemaName });
-                        if (relResult.recordset.length === 0) {
-                            logError(`    > Organic key "${okConfig.Name}": related entity "${reConfig.SchemaName}.${reConfig.TableName}" not found — skipping`);
-                            continue;
-                        }
-                        const relEntityId = relResult.recordset[0].ID;
-                        const relEntityName = relResult.recordset[0].Name;
+                    for (const { config: reConfig, entity: relEntity } of relatedEntities) {
+                        const relEntityId = relEntity.ID;
+                        const relEntityName = relEntity.Name;
                         // Check if this related entity mapping already exists
                         const existingRel = await this.runQueryWithParams(pool, `SELECT ID FROM ${this.qs(schema, 'EntityOrganicKeyRelatedEntity')} WHERE EntityOrganicKeyID = @KeyID AND RelatedEntityID = @RelEntityID`, { 'KeyID': organicKeyId, 'RelEntityID': relEntityId });
                         // Build field values
@@ -765,7 +841,7 @@ export class ManageMetadataBase {
                         DisplayLocation = '${reConfig.DisplayLocation || 'After Field Tabs'}',
                         Sequence = ${reConfig.Sequence ?? 0}
                         WHERE ID = '${relId}'`;
-                            await this.LogSQLAndExecute(pool, updateRelSQL, `Update organic key related entity: "${okConfig.Name}" → ${relEntityName}`);
+                            await this.logSQLAndExecute(pool, updateRelSQL, `Update organic key related entity: "${okConfig.Name}" → ${relEntityName}`);
                         }
                         else {
                             // Use subqueries for FK references so the logged SQL is portable across databases
@@ -785,18 +861,55 @@ export class ManageMetadataBase {
                          ${reConfig.DisplayName ? `'${reConfig.DisplayName.replace(/'/g, "''")}'` : 'NULL'},
                          '${reConfig.DisplayLocation || 'After Field Tabs'}',
                          ${reConfig.Sequence ?? 0})`;
-                            await this.LogSQLAndExecute(pool, insertRelSQL, `Insert organic key related entity: "${okConfig.Name}" → ${relEntityName}`);
+                            await this.logSQLAndExecute(pool, insertRelSQL, `Insert organic key related entity: "${okConfig.Name}" → ${relEntityName}`);
                         }
                         logStatus(`    > Organic key "${okConfig.Name}": ${existingRel.recordset.length > 0 ? 'updated' : 'created'} → ${relEntityName} (${isDirect ? 'direct' : 'transitive'})`);
                     }
                 }
                 catch (err) {
+                    // Keep going so one bad key doesn't block the others — but count it: a key that failed
+                    // here (bridge-view DDL the database rejected, a refused view drop, …) is missing from
+                    // the database, and the run must not report success for it.
+                    failedCount++;
                     const errMessage = err instanceof Error ? err.message : String(err);
                     logError(`    > Organic key config: Failed to process "${okConfig.Name}" on ${ownerEntityName}: ${errMessage}`);
                 }
             }
         }
-        return { success: true, createdCount, updatedCount };
+        return { success: failedCount === 0, createdCount, updatedCount, failedCount };
+    }
+    /**
+     * Finds the entity an organic-key config names: by base table + schema, else by entity name.
+     * Returns `null` when neither matches.
+     */
+    async findOrganicKeyEntity(pool, schemaName, tableName) {
+        const result = await this.runQueryWithParams(pool, `
+         ${this.selectTop(1, 'ID, Name', `FROM ${this.qs(MjCoreSchema(), 'vwEntities')}
+         WHERE (BaseTable = @TableName AND SchemaName = @SchemaName)
+            OR Name = @TableName`, 'CASE WHEN BaseTable = @TableName AND SchemaName = @SchemaName THEN 0 ELSE 1 END')}
+      `, { 'TableName': tableName, 'SchemaName': schemaName });
+        const row = result.recordset[0];
+        return row ? { ID: row.ID, Name: row.Name } : null;
+    }
+    /**
+     * Resolves every related entity of an organic key, in config order. Logs each one that doesn't
+     * resolve and returns `null` if any is missing, so the caller can skip the key before writing any
+     * of it.
+     */
+    async resolveOrganicKeyRelatedEntities(pool, okConfig) {
+        const resolved = [];
+        let missing = 0;
+        for (const reConfig of okConfig.RelatedEntities) {
+            const entity = await this.findOrganicKeyEntity(pool, reConfig.SchemaName, reConfig.TableName);
+            if (entity) {
+                resolved.push({ config: reConfig, entity });
+            }
+            else {
+                missing++;
+                logError(`    > Organic key "${okConfig.Name}": related entity "${reConfig.SchemaName}.${reConfig.TableName}" not found — the key is not applied`);
+            }
+        }
+        return missing === 0 ? resolved : null;
     }
     /**
      * Builds the entity lookup behind {@link processISARelationshipConfig}: match on Name first, else
@@ -840,7 +953,7 @@ export class ManageMetadataBase {
         if (relationships.length === 0)
             return { success: true, updatedCount: 0 };
         let updatedCount = 0;
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         for (const rel of relationships) {
             try {
                 // Look up the parent entity — try by Name first, then by BaseTable within the given schema
@@ -884,7 +997,7 @@ export class ManageMetadataBase {
                                   SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()},
                                       ${this.qi('ParentID')} = '${parentId}'
                                   WHERE ${this.qi('ID')} = '${childId}'`;
-                    await this.LogSQLAndExecute(pool, updateSQL, `Set IS-A ParentID for "${childName}" → "${parentName}"`);
+                    await this.logSQLAndExecute(pool, updateSQL, `Set IS-A ParentID for "${childName}" → "${parentName}"`);
                     if (existingParentId) {
                         logStatus(`    > IS-A: Updated "${childName}" ParentID from previous value to "${parentName}"`);
                     }
@@ -932,7 +1045,7 @@ export class ManageMetadataBase {
      * so a broken declaration fails before it produces generated code.
      */
     async validateISARelationships(pool) {
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         let errorCount = 0;
         try {
             const results = await this.runQuery(pool, this.buildISAValidationSQL(schema));
@@ -1023,7 +1136,7 @@ export class ManageMetadataBase {
         if (entityConfigs.length === 0)
             return { success: true, updatedCount: 0 };
         let updatedCount = 0;
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         const reservedKeys = new Set(['BaseTable', 'SchemaName']);
         for (const ec of entityConfigs) {
             try {
@@ -1088,7 +1201,7 @@ export class ManageMetadataBase {
                 const updateSQL = `UPDATE ${this.qs(schema, 'Entity')}
                               SET ${setClauses.join(', ')}
                               WHERE ${this.qi('ID')} = '${entityId}'`;
-                await this.LogSQLAndExecute(pool, updateSQL, `Update attributes on "${entityName}" from additionalSchemaInfo`);
+                await this.logSQLAndExecute(pool, updateSQL, `Update attributes on "${entityName}" from additionalSchemaInfo`);
                 const attrSummary = differingAttrs.map(a => a.summary).join(', ');
                 logStatus(`    > Entities config: Set ${attrSummary} on "${entityName}"`);
                 updatedCount++;
@@ -1114,7 +1227,7 @@ export class ManageMetadataBase {
         if (virtualEntities.length === 0)
             return { success: true, createdCount: 0 };
         let createdCount = 0;
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         for (const ve of virtualEntities) {
             const viewSchema = ve.SchemaName || schema;
             const viewName = ve.ViewName;
@@ -1190,7 +1303,7 @@ export class ManageMetadataBase {
         // Refresh so entity.Fields reflect this run's field sync before we snapshot the shape.
         const md = new Metadata(); // global-provider-ok: codegen runs offline against a single provider
         await md.Refresh();
-        const coreSchema = mj_core_schema();
+        const coreSchema = MjCoreSchema();
         const esc = (s) => s.replace(/'/g, "''");
         const lit = (s) => (s ? `'${esc(s)}'` : 'NULL');
         let processedCount = 0;
@@ -1253,8 +1366,8 @@ export class ManageMetadataBase {
             // includeBatchSeparator: each is a single GO-free batch (executed via ds.query), but the
             // migration file needs a GO between statements for Flyway/sqlcmd. Pass the provider's
             // separator, not the 'GO' default: on PostgreSQL it is '' and a literal GO breaks replay.
-            await this.LogSQLAndExecute(pool, tableSQL, `Create materialized table for base-view materialization of entity ${entity.Name}`, false, true, this.dbProvider.BatchSeparator);
-            await this.LogSQLAndExecute(pool, viewSQL, `Create wrapper view for base-view materialization of entity ${entity.Name}`, false, true, this.dbProvider.BatchSeparator);
+            await this.logSQLAndExecute(pool, tableSQL, `Create materialized table for base-view materialization of entity ${entity.Name}`, false, true, this.dbProvider.BatchSeparator);
+            await this.logSQLAndExecute(pool, viewSQL, `Create wrapper view for base-view materialization of entity ${entity.Name}`, false, true, this.dbProvider.BatchSeparator);
             // 4) Upsert the MJ: Materialized Results row, keyed on (SourceType, SourceEntityID).
             const existing = await this.runQueryWithParams(pool, `SELECT ID FROM ${this.qs(coreSchema, 'MaterializedResult')} WHERE SourceType = @SourceType AND SourceEntityID = @EntityID`, { SourceType: 'EntityBaseView', EntityID: entity.ID });
             if (existing.recordset.length > 0) {
@@ -1262,7 +1375,7 @@ export class ManageMetadataBase {
                               SET SchemaName='${esc(matSchema)}', TableName='${esc(tableName)}', ViewName='${esc(viewName)}',
                                   RefreshSchedule=${lit(decl.RefreshSchedule)}, IntendedWorkload=${lit(decl.IntendedWorkload)}
                             WHERE ID='${existing.recordset[0].ID}'`;
-                await this.LogSQLAndExecute(pool, sqlUpd, `Update MJ: Materialized Results for base-view materialization of ${entity.Name}`);
+                await this.logSQLAndExecute(pool, sqlUpd, `Update MJ: Materialized Results for base-view materialization of ${entity.Name}`);
             }
             else {
                 const newId = this.createNewUUID();
@@ -1274,7 +1387,7 @@ export class ManageMetadataBase {
                             VALUES ( '${newId}', 'EntityBaseView', '${entity.ID}', '${esc(matSchema)}', '${esc(tableName)}', '${esc(viewName)}',
                                  'None', 'FullRebuild', ${lit(decl.RefreshSchedule)}, 'Building', ${lit(decl.IntendedWorkload)},
                                  ${this.utcNow()}, ${this.utcNow()} )`;
-                await this.LogSQLAndExecute(pool, sqlIns, `Insert MJ: Materialized Results for base-view materialization of ${entity.Name}`);
+                await this.logSQLAndExecute(pool, sqlIns, `Insert MJ: Materialized Results for base-view materialization of ${entity.Name}`);
             }
             processedCount++;
             logStatus(`    > Base-view materialization ready for entity "${entity.Name}" → [${matSchema}].[${viewName}]`);
@@ -1288,7 +1401,7 @@ export class ManageMetadataBase {
      * fields, or a precise refusal (per-parameter reasons) so non-qualifying queries are skipped loudly.
      */
     async classifyParameterizedQueryForMaterialization(pool, queryId, queryName, outputColumns, currentUser) {
-        const coreSchema = mj_core_schema();
+        const coreSchema = MjCoreSchema();
         const md = new Metadata(); // global-provider-ok: codegen runs offline against a single provider
         // Load the query template + parameter definitions (typed entities for the renderer).
         const qRes = await this.runQueryWithParams(pool, `SELECT SQL, UsesTemplate FROM ${this.qs(coreSchema, 'Query')} WHERE ID = @QID`, { QID: queryId });
@@ -1320,31 +1433,31 @@ export class ManageMetadataBase {
         // Phase 2 is shipped: enable Bucket-1 row-filter broad materialization. The provider now auto-injects
         // the read-time predicate from the persisted ReadFilterSpec (bound params), so a RowFilterBroad
         // materialization is safe to mint. `allowRowFilterBroad` remains the build-level kill switch.
-        const classification = classifyQueryParameters({ queryName, params: paramDefs, outputColumns, dialect, render, allowRowFilterBroad: true });
-        if (!classification.qualification.qualifies) {
-            const detail = classification.perParam.map((pp) => `${pp.name}: ${pp.verdict.reason}`).join('; ');
-            return { qualifies: false, reason: `${classification.qualification.reason ?? 'parameters not materializable'}${detail ? ` — [${detail}]` : ''}` };
+        const classification = ClassifyQueryParameters({ queryName, params: paramDefs, outputColumns, dialect, render, allowRowFilterBroad: true });
+        if (!classification.Qualification.qualifies) {
+            const detail = classification.PerParam.map((pp) => `${pp.name}: ${pp.verdict.reason}`).join('; ');
+            return { qualifies: false, reason: `${classification.Qualification.reason ?? 'parameters not materializable'}${detail ? ` — [${detail}]` : ''}` };
         }
-        if (classification.qualification.paramMode !== 'RowFilterBroad') {
-            return { qualifies: false, reason: `parameterization mode '${classification.qualification.paramMode}' is not supported for materialization in v1 (only RowFilterBroad)` };
+        if (classification.Qualification.paramMode !== 'RowFilterBroad') {
+            return { qualifies: false, reason: `parameterization mode '${classification.Qualification.paramMode}' is not supported for materialization in v1 (only RowFilterBroad)` };
         }
         // Build the broad source SQL: render a concrete instance (held values) then strip the row-filter predicates.
         let renderedHeld;
         try {
-            renderedHeld = render(buildHeldValues(paramDefs));
+            renderedHeld = render(BuildHeldValues(paramDefs));
         }
         catch (e) {
             return { qualifies: false, reason: `could not render the query to build broad SQL: ${e instanceof Error ? e.message : String(e)}` };
         }
-        const expectedRemovals = classification.qualification.rowFilterColumns.length;
-        const broad = buildBroadRowFilterSQL(renderedHeld, classification.qualification.rowFilterColumns, dialect, expectedRemovals);
-        if (broad.removedCount === 0) {
-            return { qualifies: false, reason: `expected to strip row-filter predicate(s) on [${classification.qualification.rowFilterColumns.join(', ')}] but none were removed from the rendered SQL — refusing to avoid a wrongly-filtered materialization` };
+        const expectedRemovals = classification.Qualification.rowFilterColumns.length;
+        const broad = BuildBroadRowFilterSQL(renderedHeld, classification.Qualification.rowFilterColumns, dialect, expectedRemovals);
+        if (broad.RemovedCount === 0) {
+            return { qualifies: false, reason: `expected to strip row-filter predicate(s) on [${classification.Qualification.rowFilterColumns.join(', ')}] but none were removed from the rendered SQL — refusing to avoid a wrongly-filtered materialization` };
         }
-        if (broad.ambiguous) {
-            return { qualifies: false, reason: `expected to strip exactly ${expectedRemovals} row-filter parameter predicate(s) on [${classification.qualification.rowFilterColumns.join(', ')}] but matched ${broad.removedCount} — the parameter predicate(s) cannot be cleanly isolated from other static or same-named predicates on those columns, so a broad materialization would include or exclude rows the live query never would. Refusing (query stays live-only).` };
+        if (broad.Ambiguous) {
+            return { qualifies: false, reason: `expected to strip exactly ${expectedRemovals} row-filter parameter predicate(s) on [${classification.Qualification.rowFilterColumns.join(', ')}] but matched ${broad.RemovedCount} — the parameter predicate(s) cannot be cleanly isolated from other static or same-named predicates on those columns, so a broad materialization would include or exclude rows the live query never would. Refusing (query stays live-only).` };
         }
-        return { qualifies: true, rowFilterColumns: classification.qualification.rowFilterColumns, broadSQL: broad.sql, readFilterSpec: classification.qualification.readFilterSpec };
+        return { qualifies: true, rowFilterColumns: classification.Qualification.rowFilterColumns, broadSQL: broad.Sql, readFilterSpec: classification.Qualification.readFilterSpec };
     }
     /**
      * Processes query materialization (CodeGen materialization phase, sub-step C — plan §4.2).
@@ -1363,7 +1476,7 @@ export class ManageMetadataBase {
      * Parameterized queries are skipped with a log (deferred to Phase 2).
      */
     async processQueryMaterializations(pool, currentUser) {
-        const coreSchema = mj_core_schema();
+        const coreSchema = MjCoreSchema();
         // Gate the whole method on the IsMaterialized column existing — the flagged-query SELECT below filters on it,
         // and it (like the MaterializedResult table) is added by the materialization Foundation migration. On a DB
         // where that migration hasn't run yet the SELECT would throw and abort the entire codegen pass; with no such
@@ -1427,7 +1540,7 @@ export class ManageMetadataBase {
             // Detected BEFORE the shape analysis so the surrogate column can be typed for the keyed case.
             const detectSQL = paramMode === 'RowFilterBroad' ? (broadSQL ?? '') : querySQL;
             const matDialect = this.dbProvider.PlatformKey === 'postgresql' ? new PostgreSQLDialect() : new SQLServerDialect();
-            const detectedKeyColumns = detectSQL ? detectAggregationKeyColumns({ sql: detectSQL, dialect: matDialect, fields }) : null;
+            const detectedKeyColumns = detectSQL ? DetectAggregationKeyColumns({ sql: detectSQL, dialect: matDialect, fields }) : null;
             // An EXTERNAL query refreshes via rebuildFromExternalQuery, which fetches all rows through the EDS
             // driver and writes a SYNTHETIC row-index surrogate — it cannot compute the per-group combined-key
             // hash and ignores KeyColumns entirely. So minting a keyed (hash-surrogate) entity for an external
@@ -1453,7 +1566,7 @@ export class ManageMetadataBase {
             // The materialized table's column shape is the query's output columns — independent of
             // parameterization (a row-filter query is materialized broad over the same columns). Pass
             // isParameterized:false so the analyzer yields the shape; the param gate above already ran.
-            const analysis = analyzeQueryForMaterialization({ queryName, isParameterized: false, fields, surrogateSQLType });
+            const analysis = AnalyzeQueryForMaterialization({ queryName, isParameterized: false, fields, surrogateSQLType });
             if (!analysis.qualifies) {
                 logStatus(`    > Skipping materialization of query "${queryName}": ${analysis.reason}`);
                 continue;
@@ -1471,7 +1584,7 @@ export class ManageMetadataBase {
             const isKeyedSingleSource = isKeyed && !!detectSQL && SQLParser.ExtractTableRefs(detectSQL, matDialect).length === 1;
             const refreshStrategy = !isKeyedSingleSource
                 ? 'FullRebuild'
-                : detectAdditiveMeasures(detectSQL)
+                : DetectAdditiveMeasures(detectSQL)
                     ? 'Incremental'
                     : 'DirtyGroupRecompute';
             // RLS downgrade gate (§6.2, ships day one) — a materialized query entity does NOT inherit its
@@ -1510,10 +1623,10 @@ export class ManageMetadataBase {
                 logError(`    > REFUSING to materialize query "${queryName}": its derived table [${coreSchema}].[${tableName}] (from CodeName "${codeName}") is already owned by a different materialization (SourceType=${foreignOwner.SourceType}, QueryID=${foreignOwner.QueryID ?? 'n/a'}). Two sources whose names normalize to the same CodeName would clobber each other's snapshot — rename one so their CodeNames differ. Skipping.`);
                 continue;
             }
-            const tableSQL = this.dbProvider.generateMaterializedTableSQL(coreSchema, tableName, analysis.columns);
+            const tableSQL = this.dbProvider.generateMaterializedTableSQL(coreSchema, tableName, analysis.Columns);
             const viewSQL = this.dbProvider.generateMaterializedWrapperViewSQL(coreSchema, viewName, tableName);
-            await this.LogSQLAndExecute(pool, tableSQL, `Create materialized table for query "${queryName}"`, false, true, this.dbProvider.BatchSeparator);
-            await this.LogSQLAndExecute(pool, viewSQL, `Create wrapper view for query "${queryName}"`, false, true, this.dbProvider.BatchSeparator);
+            await this.logSQLAndExecute(pool, tableSQL, `Create materialized table for query "${queryName}"`, false, true, this.dbProvider.BatchSeparator);
+            await this.logSQLAndExecute(pool, viewSQL, `Create wrapper view for query "${queryName}"`, false, true, this.dbProvider.BatchSeparator);
             // 3) Mint the read-only Virtual Entity over the wrapper view (idempotent by view).
             const existingVE = await this.runQueryWithParams(pool, `SELECT ID FROM ${this.qs(coreSchema, 'vwEntities')} WHERE BaseView = @V AND SchemaName = @S`, { V: viewName, S: coreSchema });
             let generatedEntityId = existingVE.recordset[0]?.ID;
@@ -1523,7 +1636,7 @@ export class ManageMetadataBase {
                         Name: queryName,
                         BaseView: viewName,
                         SchemaName: coreSchema,
-                        PrimaryKeyFieldName: analysis.surrogateColumnName,
+                        PrimaryKeyFieldName: analysis.SurrogateColumnName,
                         Description: `Materialized result of query "${queryName}".`,
                     });
                     generatedEntityId = createRes.recordset?.[0]?.[''] || createRes.recordset?.[0]?.ID || createRes.recordset?.[0]?.Column0;
@@ -1562,7 +1675,7 @@ export class ManageMetadataBase {
                               SET GeneratedEntityID=${idLit(generatedEntityId)}, SchemaName='${esc(coreSchema)}', TableName='${esc(tableName)}', ViewName='${esc(viewName)}',
                                   ${this.qi('ParamMode')}='${paramMode}', ${this.qi('RowFilterColumns')}=${rowFilterColumnsLit}, ${this.qi('BroadSQL')}=${broadSQLLit}, ${this.qi('ReadFilterSpec')}=${readFilterSpecLit}, ${this.qi('KeyColumns')}=${keyColumnsLit}, ${this.qi('RefreshStrategy')}='${refreshStrategy}'
                             WHERE ID='${matResultId}'`;
-                await this.LogSQLAndExecute(pool, sqlUpd, `Update MJ: Materialized Results for query "${queryName}"`);
+                await this.logSQLAndExecute(pool, sqlUpd, `Update MJ: Materialized Results for query "${queryName}"`);
             }
             else {
                 matResultId = this.createNewUUID();
@@ -1572,13 +1685,13 @@ export class ManageMetadataBase {
                                  ${c('ParamMode')}, ${c('RowFilterColumns')}, ${c('BroadSQL')}, ${c('ReadFilterSpec')}, ${c('KeyColumns')}, ${c('RefreshStrategy')}, ${c('Status')}, ${c('__mj_CreatedAt')}, ${c('__mj_UpdatedAt')} )
                             VALUES ( '${matResultId}', 'Query', ${idLit(generatedEntityId)}, '${esc(coreSchema)}', '${esc(tableName)}', '${esc(viewName)}',
                                  '${paramMode}', ${rowFilterColumnsLit}, ${broadSQLLit}, ${readFilterSpecLit}, ${keyColumnsLit}, '${refreshStrategy}', 'Building', ${this.utcNow()}, ${this.utcNow()} )`;
-                await this.LogSQLAndExecute(pool, sqlIns, `Insert MJ: Materialized Results for query "${queryName}"`);
+                await this.logSQLAndExecute(pool, sqlIns, `Insert MJ: Materialized Results for query "${queryName}"`);
                 // Link the new materialization to its source Query via the join table.
                 const joinId = this.createNewUUID();
                 const sqlJoinIns = `INSERT INTO ${this.qs(coreSchema, 'MaterializedResultQuery')} (
                                  ${c('ID')}, ${c('MaterializedResultID')}, ${c('QueryID')}, ${c('__mj_CreatedAt')}, ${c('__mj_UpdatedAt')} )
                             VALUES ( '${joinId}', '${matResultId}', '${queryId}', ${this.utcNow()}, ${this.utcNow()} )`;
-                await this.LogSQLAndExecute(pool, sqlJoinIns, `Link MJ: Materialized Results to Query "${queryName}" via join row`);
+                await this.logSQLAndExecute(pool, sqlJoinIns, `Link MJ: Materialized Results to Query "${queryName}" via join row`);
             }
             processedCount++;
         }
@@ -1595,7 +1708,7 @@ export class ManageMetadataBase {
      * auto-rebuilds. Already-held (`DriftHold`) and `Disabled` rows are skipped.
      */
     async detectMaterializationDrift(pool) {
-        const coreSchema = mj_core_schema();
+        const coreSchema = MjCoreSchema();
         // Gate on MaterializedResult existing — the SELECT below reads it. Absent (materialization migration not yet
         // applied on this DB) ⇒ no materializations exist to check for drift; skip cleanly rather than throwing and
         // aborting the codegen pass.
@@ -1700,14 +1813,14 @@ export class ManageMetadataBase {
                 // would only stop FUTURE refreshes while leaving the already-populated rows queryable via raw SQL
                 // over the wrapper view. Emptying (not dropping) removes the leaked data without breaking any object
                 // dependency; the wrapper view remains but returns nothing. Then DriftHold so refresh never refills it.
-                await this.LogSQLAndExecute(pool, `DELETE FROM ${this.qs(r.SchemaName, r.TableName)}`, `Empty external RLS base-view mirror "${r.TableName}" (leak guard — mirror exposed RLS-refused rows)`);
-                await this.LogSQLAndExecute(pool, `UPDATE ${this.qs(coreSchema, 'MaterializedResult')} SET ${this.qi('Status')}='DriftHold' WHERE ID='${r.ID}'`, `Flag external RLS base-view materialization "${r.TableName}" as DriftHold (leak guard)`);
+                await this.logSQLAndExecute(pool, `DELETE FROM ${this.qs(r.SchemaName, r.TableName)}`, `Empty external RLS base-view mirror "${r.TableName}" (leak guard — mirror exposed RLS-refused rows)`);
+                await this.logSQLAndExecute(pool, `UPDATE ${this.qs(coreSchema, 'MaterializedResult')} SET ${this.qi('Status')}='DriftHold' WHERE ID='${r.ID}'`, `Flag external RLS base-view materialization "${r.TableName}" as DriftHold (leak guard)`);
                 logError(`    > RLS LEAK GUARD: base-view materialization "${r.TableName}" mirrors an EXTERNAL row-restricted entity ("${bvEntity.Name}" — role RLS and/or an API-key row filter) → mirror EMPTIED + DriftHold (refresh stopped). It exposed rows the live path refuses under RLS.`);
                 return true;
             }
         }
         const facts = await this.gatherDriftFacts(pool, md, r, coreSchema);
-        const verdict = evaluateMaterializationDrift(facts);
+        const verdict = EvaluateMaterializationDrift(facts);
         if (verdict.drift) {
             // Fail-closed on ANY hold of a QUERY materialization: once held, the row drops out of
             // detectMaterializationDrift's `Status NOT IN ('DriftHold', ...)` scan, so the C1 RLS re-check and the
@@ -1719,7 +1832,7 @@ export class ManageMetadataBase {
             if (r.SourceType === 'Query' && r.GeneratedEntityID) {
                 await this.revokeMaterializedEntityReadAccess(pool, r.GeneratedEntityID, r.TableName, `drift hold — ${verdict.reason ?? 'shape/provenance drift'}`);
             }
-            await this.LogSQLAndExecute(pool, `UPDATE ${this.qs(coreSchema, 'MaterializedResult')} SET ${this.qi('Status')}='DriftHold' WHERE ID='${r.ID}'`, `Flag materialization "${r.TableName}" as DriftHold`);
+            await this.logSQLAndExecute(pool, `UPDATE ${this.qs(coreSchema, 'MaterializedResult')} SET ${this.qi('Status')}='DriftHold' WHERE ID='${r.ID}'`, `Flag materialization "${r.TableName}" as DriftHold`);
             logStatus(`    > DRIFT: materialization "${r.TableName}" → DriftHold — ${verdict.reason}`);
             return true;
         }
@@ -1753,7 +1866,7 @@ export class ManageMetadataBase {
         if (r.GeneratedEntityID) {
             await this.revokeMaterializedEntityReadAccess(pool, r.GeneratedEntityID, r.TableName, reason);
         }
-        await this.LogSQLAndExecute(pool, `UPDATE ${this.qs(coreSchema, 'MaterializedResult')} SET ${this.qi('Status')}='DriftHold' WHERE ID='${r.ID}'`, `Flag materialization "${r.TableName}" as DriftHold (${label.toLowerCase()})`);
+        await this.logSQLAndExecute(pool, `UPDATE ${this.qs(coreSchema, 'MaterializedResult')} SET ${this.qi('Status')}='DriftHold' WHERE ID='${r.ID}'`, `Flag materialization "${r.TableName}" as DriftHold (${label.toLowerCase()})`);
         logError(`    > ${label}: materialization "${r.TableName}" → read access revoked + DriftHold — ${reason}`);
     }
     /** Gathers the drift-relevant existence facts for one materialization against current metadata. */
@@ -1864,7 +1977,7 @@ export class ManageMetadataBase {
      * @param pool - the ConnectionPool object to use for querying and updating the database
      * @returns
      */
-    async manageMetadata(pool, currentUser) {
+    async ManageMetadata(pool, currentUser) {
         const md = new Metadata(); // global-provider-ok: codegen runs offline against a single provider
         // Auto-exclude platform-specific system schemas.
         // We mutate configInfo.excludeSchemas directly so that all downstream code
@@ -1885,7 +1998,7 @@ export class ManageMetadataBase {
         // machinery — when the provider supplies DDL (PostgreSQL), we install it
         // idempotently here rather than depending on migrations to have shipped
         // it. Nothing below can work without them, so a failure here is fatal.
-        const supportObjectsSQL = this.dbProvider.getMetadataSupportObjectsSQL(mj_core_schema());
+        const supportObjectsSQL = this.dbProvider.getMetadataSupportObjectsSQL(MjCoreSchema());
         if (supportObjectsSQL) {
             try {
                 await pool.query(supportObjectsSQL);
@@ -1899,7 +2012,7 @@ export class ManageMetadataBase {
         // Authored exclude list (sys, staging, …) must be captured BEFORE includeSchemas is
         // compiled into excludeSchemas. Heal EXEC statements use that original list plus
         // @IncludedSchemaNames — never the sibling snapshot of this machine's database.
-        snapshotAuthoredExcludeSchemas(configInfo.excludeSchemas);
+        SnapshotAuthoredExcludeSchemas(configInfo.excludeSchemas);
         // Resolve the opt-in `includeSchemas` positive scope into excludeSchemas, BEFORE the exclude
         // snapshot below and before createNewEntities() runs. The universe is queried from the DATABASE
         // rather than taken from loaded metadata on purpose: createNewEntities() discovers tables with no
@@ -1909,12 +2022,12 @@ export class ManageMetadataBase {
         // every run after, orphaning its entity records). No-op when includeSchemas is unset.
         if (configInfo.includeSchemas && configInfo.includeSchemas.length > 0) {
             try {
-                const schemaSQL = `SELECT DISTINCT ${this.qi('SchemaName')} FROM ${this.qs(mj_core_schema(), 'vwSQLTablesAndEntities')}`;
+                const schemaSQL = `SELECT DISTINCT ${this.qi('SchemaName')} FROM ${this.qs(MjCoreSchema(), 'vwSQLTablesAndEntities')}`;
                 const schemaResult = await this.runQuery(pool, schemaSQL);
                 const allSchemas = (schemaResult.recordset ?? [])
                     .map((r) => r.SchemaName)
                     .filter((s) => !!s);
-                const newlyExcluded = applyIncludeSchemaScope(allSchemas, configInfo);
+                const newlyExcluded = ApplyIncludeSchemaScope(allSchemas, configInfo);
                 logStatus(`   Applied includeSchemas scope [${configInfo.includeSchemas.join(', ')}] — excluded ${newlyExcluded.length} other schema(s) present in the database`);
             }
             catch (e) {
@@ -1964,12 +2077,12 @@ export class ManageMetadataBase {
         start = new Date();
         logStatus('   Recompiling base views...');
         const sqlUtility = MJGlobal.Instance.ClassFactory.CreateInstance(SQLUtilityBase);
-        const adminSchema = getSettingValue('mj_core_schema', '__mj');
-        const schemasToExclude = getSettingValue('recompile_mj_views', true)
+        const adminSchema = GetSettingValue('mj_core_schema', '__mj');
+        const schemasToExclude = GetSettingValue('recompile_mj_views', true)
             ? excludeSchemas.filter((s) => s !== adminSchema)
             : excludeSchemas;
         if (!await sqlUtility.recompileAllBaseViews(pool, schemasToExclude, true, ManageMetadataBase._newEntityList /*exclude the newly created entities from the above step the first time we run as those views don't exist yet*/)) {
-            logMessage('   Warning: Non-Fatal error recompiling base views', SeverityType.Warning, false);
+            LogMessage('   Warning: Non-Fatal error recompiling base views', SeverityType.Warning, false);
             // many times the former versions of base views will NOT succesfully recompile, so don't consider that scenario to be a
             // failure for this entire function
         }
@@ -1980,7 +2093,7 @@ export class ManageMetadataBase {
         // Also skip deleting unneeded fields on this first pass — base views haven't been regenerated yet,
         // so virtual fields (which come from view JOINs) would be incorrectly identified as orphaned and deleted.
         // Deletion runs on the second pass (in sql_codegen.ts) after views are current.
-        if (!await this.manageEntityFields(pool, excludeSchemas, false, false, currentUser, true, true)) {
+        if (!await this.ManageEntityFields(pool, excludeSchemas, false, false, currentUser, true, true)) {
             logError('   Error managing entity fields');
             bSuccess = false;
         }
@@ -2062,6 +2175,10 @@ export class ManageMetadataBase {
         if (organicKeyResult.createdCount > 0 || organicKeyResult.updatedCount > 0) {
             logStatus(`    > Organic keys: ${organicKeyResult.createdCount} created, ${organicKeyResult.updatedCount} updated from config`);
         }
+        if (!organicKeyResult.success) {
+            logError(`   Error processing organic keys: ${organicKeyResult.failedCount} key(s) failed and were not applied — see the errors above`);
+            bSuccess = false;
+        }
         // Config-driven base-view materialization — emit the physical table + wrapper view and
         // attach an "MJ: Materialized Results" row to the existing entity. Runs AFTER entity fields
         // are managed so the snapshot shape reflects the current base view (plan §4.1).
@@ -2089,6 +2206,10 @@ export class ManageMetadataBase {
         await this.checkEntityFieldSequenceIntegrity(pool, excludeSchemas);
         return bSuccess;
     }
+    /** @deprecated Use {@link ManageMetadata}. */
+    async manageMetadata(pool, currentUser) {
+        return this.ManageMetadata(pool, currentUser);
+    }
     /**
      * INTEGRITY CHECK — in a well-formed entity every base (non-virtual) field sequences BEFORE the
      * virtual/related fields, so the EntityField order matches the base view's `SELECT [base].*, <joins>`
@@ -2102,10 +2223,10 @@ export class ManageMetadataBase {
     async checkEntityFieldSequenceIntegrity(pool, excludeSchemas) {
         try {
             const excl = excludeSchemas.length > 0
-                ? `WHERE ${this.qi('EntityID')} NOT IN (SELECT ${this.qi('ID')} FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE ${this.qi('SchemaName')} IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))`
+                ? `WHERE ${this.qi('EntityID')} NOT IN (SELECT ${this.qi('ID')} FROM ${this.qs(MjCoreSchema(), 'Entity')} WHERE ${this.qi('SchemaName')} IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))`
                 : '';
             const sSQL = `SELECT ${this.qi('EntityID')}, ${this.qi('Entity')}, ${this.qi('Name')}, ${this.qi('Sequence')}, ${this.qi('IsVirtual')}
-                       FROM ${this.qs(mj_core_schema(), 'vwEntityFields')}
+                       FROM ${this.qs(MjCoreSchema(), 'vwEntityFields')}
                        ${excl}
                        ORDER BY ${this.qi('EntityID')}, ${this.qi('Sequence')}, ${this.qi('Name')}`;
             const result = await this.runQuery(pool, sSQL);
@@ -2157,7 +2278,7 @@ export class ManageMetadataBase {
         // virtual entities are records defined in the entity metadata and do NOT define a distinct base table
         // but they do specify a base view. We DO NOT generate a base view for a virtual entity, we simply use it to figure
         // out the fields that should be in the entity definition and add/update/delete the entity definition to match what's in the view when this runs
-        const sql = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntities')} WHERE VirtualEntity = ${this.boolLit(true)}`;
+        const sql = `SELECT * FROM ${this.qs(MjCoreSchema(), 'vwEntities')} WHERE VirtualEntity = ${this.boolLit(true)}`;
         const virtualEntitiesResult = await this.runQuery(pool, sql);
         const virtualEntities = virtualEntitiesResult.recordset;
         let anyUpdates = false;
@@ -2217,7 +2338,7 @@ export class ManageMetadataBase {
     async materializedResultTableExists(pool) {
         if (this._materializedResultTableExists === null) {
             const sql = `SELECT COUNT(*) AS TblExists FROM INFORMATION_SCHEMA.TABLES ` +
-                `WHERE TABLE_SCHEMA = '${mj_core_schema()}' AND TABLE_NAME = 'MaterializedResult'`;
+                `WHERE TABLE_SCHEMA = '${MjCoreSchema()}' AND TABLE_NAME = 'MaterializedResult'`;
             const result = await this.runQuery(pool, sql);
             const row = (result.recordset?.[0] ?? {});
             const cnt = row.TblExists ?? row.tblexists ?? 0;
@@ -2235,7 +2356,7 @@ export class ManageMetadataBase {
         if (!(await this.entityHasExternalDataSourceColumn(pool))) {
             return { success: true, anyUpdates: false, relationshipsUpdated: false };
         }
-        const sql = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntities')} WHERE ExternalDataSourceID IS NOT NULL`;
+        const sql = `SELECT * FROM ${this.qs(MjCoreSchema(), 'vwEntities')} WHERE ExternalDataSourceID IS NOT NULL`;
         const result = await this.runQuery(pool, sql);
         const externalEntities = result.recordset;
         if (!externalEntities || externalEntities.length === 0) {
@@ -2352,16 +2473,16 @@ export class ManageMetadataBase {
             }
             // Map each introspected column into the veField shape that manageSingleVirtualEntityField consumes.
             const eeFields = obj.Columns.map(c => {
-                const t = mapExternalNativeTypeToMJ(c.NativeType);
+                const t = MapExternalNativeTypeToMJ(c.NativeType);
                 return { FieldName: c.Name, Type: t.Type, Length: t.Length, Precision: t.Precision, Scale: t.Scale, AllowsNull: c.Nullable, IsPrimaryKey: c.IsPrimaryKey };
             });
             const md = new Metadata(); // global-provider-ok: codegen runs offline against a single provider
             const entity = md.EntityByName(externalEntity.Name);
             if (entity) {
                 // remove EntityFields no longer present in the remote object
-                const sqlRemove = this.buildExternalFieldRemoveSQL(mj_core_schema(), entity.Fields, eeFields.map(ef => ef.FieldName));
+                const sqlRemove = this.buildExternalFieldRemoveSQL(MjCoreSchema(), entity.Fields, eeFields.map(ef => ef.FieldName));
                 if (sqlRemove) {
-                    await this.LogSQLAndExecute(pool, sqlRemove, `SQL text to remove fields from external entity ${externalEntity.Name}`);
+                    await this.logSQLAndExecute(pool, sqlRemove, `SQL text to remove fields from external entity ${externalEntity.Name}`);
                     bUpdated = true;
                 }
                 // create/update each remote column. Use the real PK info from introspection; fall back
@@ -2392,8 +2513,8 @@ export class ManageMetadataBase {
                 }
             }
             if (bUpdated) {
-                const sqlUpdate = `UPDATE ${this.qs(mj_core_schema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${externalEntity.ID}'`;
-                await this.LogSQLAndExecute(pool, sqlUpdate, `SQL text to update external entity updated date for ${externalEntity.Name}`);
+                const sqlUpdate = `UPDATE ${this.qs(MjCoreSchema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${externalEntity.ID}'`;
+                await this.logSQLAndExecute(pool, sqlUpdate, `SQL text to update external entity updated date for ${externalEntity.Name}`);
             }
             return { success: bSuccess, updatedEntity: bUpdated, relationshipsUpdated: bRelationshipsUpdated };
         }
@@ -2450,7 +2571,7 @@ export class ManageMetadataBase {
             if (alreadySet) {
                 continue;
             }
-            sqlStatements.push(`UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+            sqlStatements.push(`UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                          SET RelatedEntityID='${relatedEntity.ID}',
                              RelatedEntityFieldName='${refColumn.replace(/'/g, "''")}',
                              IsSoftForeignKey=1
@@ -2460,7 +2581,7 @@ export class ManageMetadataBase {
         if (sqlStatements.length === 0) {
             return false;
         }
-        await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set external foreign keys for ${externalEntity.Name}`);
+        await this.logSQLBatchAndExecute(pool, sqlStatements, `Set external foreign keys for ${externalEntity.Name}`);
         return true;
     }
     async manageSingleVirtualEntity(pool, virtualEntity) {
@@ -2484,9 +2605,9 @@ export class ManageMetadataBase {
                         removeList.push(f.ID);
                     }
                     if (removeList.length > 0) {
-                        const sqlRemove = `DELETE FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID IN (${removeList.map(removeId => `'${removeId}'`).join(',')})`;
+                        const sqlRemove = `DELETE FROM ${this.qs(MjCoreSchema(), 'EntityField')} WHERE ID IN (${removeList.map(removeId => `'${removeId}'`).join(',')})`;
                         // this removes the fields that shouldn't be there anymore
-                        await this.LogSQLAndExecute(pool, sqlRemove, `SQL text to remove fields from entity ${virtualEntity.Name}`);
+                        await this.logSQLAndExecute(pool, sqlRemove, `SQL text to remove fields from entity ${virtualEntity.Name}`);
                         bUpdated = true;
                     }
                     // check to see if any of the fields in the virtual entity have Pkey attribute set. If not, we will default to the first field
@@ -2506,8 +2627,8 @@ export class ManageMetadataBase {
             }
             if (bUpdated) {
                 // finally make sure we update the UpdatedAt field for the entity if we made changes to its fields
-                const sqlUpdate = `UPDATE ${this.qs(mj_core_schema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${virtualEntity.ID}'`;
-                await this.LogSQLAndExecute(pool, sqlUpdate, `SQL text to update virtual entity updated date for ${virtualEntity.Name}`);
+                const sqlUpdate = `UPDATE ${this.qs(MjCoreSchema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${virtualEntity.ID}'`;
+                await this.logSQLAndExecute(pool, sqlUpdate, `SQL text to update virtual entity updated date for ${virtualEntity.Name}`);
             }
             return { success: bSuccess, updatedEntity: bUpdated };
         }
@@ -2575,7 +2696,7 @@ export class ManageMetadataBase {
                     field.Sequence !== fieldSequence) {
                     // the field needs to be updated, so update it
                     const sqlUpdate = `UPDATE
-                                    ${this.qs(mj_core_schema(), 'EntityField')}
+                                    ${this.qs(MjCoreSchema(), 'EntityField')}
                                   SET
                                     Sequence=${fieldSequence},
                                     Type='${veField.Type}',
@@ -2586,7 +2707,7 @@ export class ManageMetadataBase {
                                     Scale=${veField.Scale}
                                   WHERE
                                     ID = '${field.ID}'`; // don't need to update the __mj_UpdatedAt field here, that happens automatically via the trigger
-                    await this.LogSQLAndExecute(pool, sqlUpdate, `SQL text to update virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
+                    await this.logSQLAndExecute(pool, sqlUpdate, `SQL text to update virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
                     didUpdate = true;
                 }
             }
@@ -2596,7 +2717,7 @@ export class ManageMetadataBase {
                 // Apply-time Sequence: see applyTimeEntityFieldSequenceSQL. A literal here would be
                 // replayed verbatim from the CodeGen capture and collide on a fresh install.
                 const q = (n) => this.qi(n);
-                const sqlAdd = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')} (
+                const sqlAdd = `INSERT INTO ${this.qs(MjCoreSchema(), 'EntityField')} (
                                       ${q('ID')}, ${q('EntityID')}, ${q('Name')}, ${q('Type')}, ${q('AllowsNull')},
                                       ${q('Length')}, ${q('Precision')}, ${q('Scale')},
                                       ${q('Sequence')}, ${q('IsPrimaryKey')}, ${q('IsUnique')},
@@ -2606,7 +2727,7 @@ export class ManageMetadataBase {
                                        ${this.applyTimeEntityFieldSequenceSQL(entity.ID)}, ${this.boolLit(wantPrimaryKey)}, ${this.boolLit(wantUnique)},
                                        ${this.utcNow()}, ${this.utcNow()}
                                     )`;
-                await this.LogSQLAndExecute(pool, sqlAdd, `SQL text to add virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
+                await this.logSQLAndExecute(pool, sqlAdd, `SQL text to add virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
                 ManageMetadataBase.registerNewField(entity.ID, veField.FieldName);
                 didUpdate = true;
             }
@@ -2702,7 +2823,7 @@ export class ManageMetadataBase {
                 return { decorated: false, skipped: false };
             }
             // Apply results to EntityField records
-            const schema = mj_core_schema();
+            const schema = MjCoreSchema();
             let anyUpdated = false;
             // Apply primary keys
             anyUpdated = await this.applyLLMPrimaryKeys(pool, entity, result.primaryKeys, schema) || anyUpdated;
@@ -2714,7 +2835,7 @@ export class ManageMetadataBase {
             anyUpdated = await this.applyVEFieldCategories(pool, entity, result) || anyUpdated;
             if (anyUpdated) {
                 const sqlUpdate = `UPDATE ${this.qs(schema, 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${entity.ID}'`;
-                await this.LogSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${entity.Name} after LLM decoration`);
+                await this.logSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${entity.Name} after LLM decoration`);
             }
             return { decorated: anyUpdated, skipped: false };
         }
@@ -2768,7 +2889,7 @@ export class ManageMetadataBase {
             return false;
         }
         // Load VE EntityField rows from DB (we need the ID and auto-update flags)
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         const fieldsSQL = `
          SELECT ID, Name, Category, AutoUpdateCategory, AutoUpdateDisplayName, AutoUpdateExtendedType, GeneratedFormSection, DisplayName, ExtendedType, CodeType, ValueListType
          FROM ${this.qs(schema, 'EntityField')}
@@ -2832,7 +2953,7 @@ export class ManageMetadataBase {
                          WHERE EntityID='${entity.ID}' AND Name='${pk}'`);
             logStatus(`         ✓ Set PK for ${entity.Name}.${pk} (LLM-identified)`);
         }
-        await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set LLM-identified PKs for ${entity.Name}: ${validPKs.join(', ')}`);
+        await this.logSQLBatchAndExecute(pool, sqlStatements, `Set LLM-identified PKs for ${entity.Name}: ${validPKs.join(', ')}`);
         return true;
     }
     /**
@@ -2877,7 +2998,7 @@ export class ManageMetadataBase {
         if (sqlStatements.length === 0) {
             return false;
         }
-        await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set LLM-identified FKs for ${entity.Name}`);
+        await this.logSQLBatchAndExecute(pool, sqlStatements, `Set LLM-identified FKs for ${entity.Name}`);
         return true;
     }
     /**
@@ -2917,7 +3038,7 @@ export class ManageMetadataBase {
         if (sqlStatements.length === 0) {
             return false;
         }
-        await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set LLM-generated descriptions for ${entity.Name} (${sqlStatements.length} fields)`);
+        await this.logSQLBatchAndExecute(pool, sqlStatements, `Set LLM-generated descriptions for ${entity.Name} (${sqlStatements.length} fields)`);
         return true;
     }
     /**
@@ -3042,7 +3163,7 @@ export class ManageMetadataBase {
             // unquoted reference folds to lower case on PostgreSQL — `column "length" does not exist`.
             // SQL Server's case-insensitive resolution hid this for as long as IS-A ran only there.
             const existsResult = await this.runQueryWithParams(pool, `SELECT ${this.qi('ID')}, ${this.qi('IsVirtual')}, ${this.qi('Type')}, ${this.qi('Length')}, ${this.qi('Precision')}, ${this.qi('Scale')}, ${this.qi('AllowsNull')}, ${this.qi('AllowUpdateAPI')}
-                    FROM ${this.qs(mj_core_schema(), 'EntityField')}
+                    FROM ${this.qs(MjCoreSchema(), 'EntityField')}
                     WHERE ${this.qi('EntityID')} = @EntityID AND ${this.qi('Name')} = @FieldName`, { 'EntityID': childEntity.ID, 'FieldName': parentField.Name });
             if (existsResult.recordset.length > 0) {
                 // Field already exists — update it to ensure it's marked as a virtual IS-A field
@@ -3055,7 +3176,7 @@ export class ManageMetadataBase {
                     existingRow.AllowsNull !== parentField.AllowsNull ||
                     !existingRow.AllowUpdateAPI;
                 if (needsUpdate) {
-                    const sqlUpdate = `UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+                    const sqlUpdate = `UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                   SET ${this.qi('IsVirtual')}=${this.boolLit(true)},
                       ${this.qi('Type')}='${parentField.Type}',
                       ${this.qi('Length')}=${parentField.Length},
@@ -3064,7 +3185,7 @@ export class ManageMetadataBase {
                       ${this.qi('AllowsNull')}=${this.boolLit(parentField.AllowsNull)},
                       ${this.qi('AllowUpdateAPI')}=${this.boolLit(true)}
                   WHERE ${this.qi('ID')}='${existingRow.ID}'`;
-                    await this.LogSQLAndExecute(pool, sqlUpdate, `Update IS-A parent field ${parentField.Name} on ${childEntity.Name}`);
+                    await this.logSQLAndExecute(pool, sqlUpdate, `Update IS-A parent field ${parentField.Name} on ${childEntity.Name}`);
                     bUpdated = true;
                 }
             }
@@ -3074,7 +3195,7 @@ export class ManageMetadataBase {
                 // Apply-time Sequence (see applyTimeEntityFieldSequenceSQL); reordered by
                 // updateExistingEntityFieldsFromSchema afterwards.
                 const q = (n) => this.qi(n);
-                const sqlInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')} (
+                const sqlInsert = `INSERT INTO ${this.qs(MjCoreSchema(), 'EntityField')} (
                   ${q('ID')}, ${q('EntityID')}, ${q('Name')}, ${q('Type')}, ${q('AllowsNull')},
                   ${q('Length')}, ${q('Precision')}, ${q('Scale')},
                   ${q('Sequence')}, ${q('IsVirtual')}, ${q('AllowUpdateAPI')},
@@ -3086,7 +3207,7 @@ export class ManageMetadataBase {
                   ${parentField.Length}, ${parentField.Precision}, ${parentField.Scale},
                   ${this.applyTimeEntityFieldSequenceSQL(childEntity.ID)}, ${this.boolLit(true)}, ${this.boolLit(true)}, ${this.boolLit(false)}, ${this.boolLit(false)},
                   ${this.utcNow()}, ${this.utcNow()})`;
-                await this.LogSQLAndExecute(pool, sqlInsert, `Create IS-A parent field ${parentField.Name} on ${childEntity.Name}`);
+                await this.logSQLAndExecute(pool, sqlInsert, `Create IS-A parent field ${parentField.Name} on ${childEntity.Name}`);
                 ManageMetadataBase.registerNewField(childEntity.ID, parentField.Name);
                 bUpdated = true;
             }
@@ -3098,13 +3219,13 @@ export class ManageMetadataBase {
             !f.IsPrimaryKey && !f.Name.startsWith('__mj_') &&
             !currentParentFieldNames.has(f.Name.toLowerCase()));
         for (const staleField of staleFields) {
-            const sqlDelete = `DELETE FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID='${staleField.ID}'`;
-            await this.LogSQLAndExecute(pool, sqlDelete, `Remove stale IS-A parent field ${staleField.Name} from ${childEntity.Name}`);
+            const sqlDelete = `DELETE FROM ${this.qs(MjCoreSchema(), 'EntityField')} WHERE ID='${staleField.ID}'`;
+            await this.logSQLAndExecute(pool, sqlDelete, `Remove stale IS-A parent field ${staleField.Name} from ${childEntity.Name}`);
             bUpdated = true;
         }
         if (bUpdated) {
-            const sqlUpdate = `UPDATE ${this.qs(mj_core_schema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${childEntity.ID}'`;
-            await this.LogSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${childEntity.Name} after IS-A field sync`);
+            const sqlUpdate = `UPDATE ${this.qs(MjCoreSchema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${childEntity.ID}'`;
+            await this.logSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${childEntity.Name} after IS-A field sync`);
         }
         return { success: true, updated: bUpdated };
     }
@@ -3155,16 +3276,16 @@ export class ManageMetadataBase {
         try {
             // STEP 1 - search for all foreign keys in the vwEntityFields view, we use the RelatedEntityID field to determine our FKs
             const sSQL = `SELECT *
-                       FROM ${this.qs(mj_core_schema(), 'vwEntityFields')}
+                       FROM ${this.qs(MjCoreSchema(), 'vwEntityFields')}
                        WHERE
                              RelatedEntityID IS NOT NULL AND
                              IsVirtual = ${this.boolLit(false)} AND
-                             EntityID NOT IN (SELECT ID FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
+                             EntityID NOT IN (SELECT ID FROM ${this.qs(MjCoreSchema(), 'Entity')} WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
                        ORDER BY RelatedEntityID, EntityID, Sequence, ID`;
             const entityFieldsResult = await this.runQuery(pool, sSQL);
             const entityFields = entityFieldsResult.recordset;
             // Get the relationship counts for each entity
-            const sSQLRelationshipCount = `SELECT ${this.qi('EntityID')}, COUNT(*) AS ${this.qi('Count')} FROM ${this.qs(mj_core_schema(), 'EntityRelationship')} GROUP BY ${this.qi('EntityID')}`;
+            const sSQLRelationshipCount = `SELECT ${this.qi('EntityID')}, COUNT(*) AS ${this.qi('Count')} FROM ${this.qs(MjCoreSchema(), 'EntityRelationship')} GROUP BY ${this.qi('EntityID')}`;
             const relationshipCountsResult = await this.runQuery(pool, sSQLRelationshipCount);
             const relationshipCounts = relationshipCountsResult.recordset;
             const relationshipCountMap = new Map();
@@ -3173,7 +3294,7 @@ export class ManageMetadataBase {
                 relationshipCountMap.set(rc.EntityID, Number(rc.Count));
             }
             // get all relationships in one query for performance improvement
-            const sSQLRelationship = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityRelationship')}`;
+            const sSQLRelationship = `SELECT * FROM ${this.qs(MjCoreSchema(), 'EntityRelationship')}`;
             const allRelationshipsResult = await this.runQuery(pool, sSQLRelationship);
             const allRelationships = allRelationshipsResult.recordset;
             // Group FK fields by entity pair (ParentEntityID -> ChildEntityID) so we can
@@ -3199,12 +3320,12 @@ export class ManageMetadataBase {
                 }
                 batchCount++;
                 if (batchCount % batchItems === 0 && batchSQL.length > 0) {
-                    await this.LogSQLAndExecute(pool, batchSQL);
+                    await this.logSQLAndExecute(pool, batchSQL);
                     batchSQL = '';
                 }
             }
             if (batchSQL.length > 0) {
-                await this.LogSQLAndExecute(pool, batchSQL);
+                await this.logSQLAndExecute(pool, batchSQL);
             }
             // NOTE: Stale relationship cleanup is intentionally NOT done here because this
             // method runs BEFORE deleteUnneededEntityFields(). Stale EntityField records
@@ -3245,8 +3366,8 @@ export class ManageMetadataBase {
         const relCount = relationshipCountMap.get(parentEntityID) || 0;
         const sequence = relCount + 1;
         const newEntityRelationshipUUID = this.createNewUUID();
-        const checkQuery = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'EntityRelationship')} WHERE ${this.qi('ID')} = '${newEntityRelationshipUUID}'`;
-        const insertSQL = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityRelationship')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('RelatedEntityID')}, ${this.qi('RelatedEntityJoinField')}, ${this.qi('Type')}, ${this.qi('BundleInAPI')}, ${this.qi('DisplayInForm')}, ${this.qi('Sequence')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')})
+        const checkQuery = `SELECT 1 FROM ${this.qs(MjCoreSchema(), 'EntityRelationship')} WHERE ${this.qi('ID')} = '${newEntityRelationshipUUID}'`;
+        const insertSQL = `INSERT INTO ${this.qs(MjCoreSchema(), 'EntityRelationship')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('RelatedEntityID')}, ${this.qi('RelatedEntityJoinField')}, ${this.qi('Type')}, ${this.qi('BundleInAPI')}, ${this.qi('DisplayInForm')}, ${this.qi('Sequence')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')})
                     VALUES ('${newEntityRelationshipUUID}', '${f.RelatedEntityID}', '${f.EntityID}', '${f.Name}', 'One To Many', ${this.boolLit(true)}, ${this.boolLit(true)}, ${sequence}, ${this.utcNow()}, ${this.utcNow()})`;
         relationshipCountMap.set(parentEntityID, sequence);
         return `
@@ -3308,7 +3429,7 @@ export class ManageMetadataBase {
                 logStatus(`      > Updating EntityRelationship join field: ${oldJoinField} -> ${newJoinField} (ID: ${r.ID})`);
                 sql += `
 /* Update EntityRelationship join field from '${oldJoinField}' to '${newJoinField}' */
-   UPDATE ${this.qs(mj_core_schema(), 'EntityRelationship')}
+   UPDATE ${this.qs(MjCoreSchema(), 'EntityRelationship')}
       SET ${this.qi('RelatedEntityJoinField')} = '${newJoinField}',
           ${this.qi('__mj_UpdatedAt')} = ${this.utcNow()}
       WHERE ${this.qi('ID')} = '${r.ID}';
@@ -3330,18 +3451,18 @@ export class ManageMetadataBase {
      * @param pool - database connection
      * @param excludeSchemas - schemas to exclude from FK field lookup
      */
-    async cleanupStaleEntityRelationships(pool, excludeSchemas) {
+    async CleanupStaleEntityRelationships(pool, excludeSchemas) {
         try {
             const sSQL = `SELECT *
-                       FROM ${this.qs(mj_core_schema(), 'vwEntityFields')}
+                       FROM ${this.qs(MjCoreSchema(), 'vwEntityFields')}
                        WHERE
                              RelatedEntityID IS NOT NULL AND
                              IsVirtual = ${this.boolLit(false)} AND
-                             EntityID NOT IN (SELECT ID FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
+                             EntityID NOT IN (SELECT ID FROM ${this.qs(MjCoreSchema(), 'Entity')} WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
                        ORDER BY RelatedEntityID, EntityID, Sequence, ID`;
             const entityFieldsResult = await this.runQuery(pool, sSQL);
             const entityFields = entityFieldsResult.recordset;
-            const sSQLRelationship = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityRelationship')}`;
+            const sSQLRelationship = `SELECT * FROM ${this.qs(MjCoreSchema(), 'EntityRelationship')}`;
             const allRelationshipsResult = await this.runQuery(pool, sSQLRelationship);
             const allRelationships = allRelationshipsResult.recordset;
             await this.removeStaleOneToManyRelationships(pool, allRelationships, entityFields);
@@ -3352,6 +3473,10 @@ export class ManageMetadataBase {
             return false;
         }
     }
+    /** @deprecated Use {@link CleanupStaleEntityRelationships}. */
+    async cleanupStaleEntityRelationships(pool, excludeSchemas) {
+        return this.CleanupStaleEntityRelationships(pool, excludeSchemas);
+    }
     /**
      * Removes stale One-To-Many EntityRelationship records whose RelatedEntityJoinField no longer
      * corresponds to a valid FK field in the database. Only removes relationships where
@@ -3374,10 +3499,10 @@ export class ManageMetadataBase {
                 logStatus(`      > Removing stale EntityRelationship: ${r.Entity} -> ${r.RelatedEntity} via '${r.RelatedEntityJoinField}' (ID: ${r.ID})`);
                 deleteSQL += `
 /* Remove stale EntityRelationship: ${r.Entity} -> ${r.RelatedEntity} (FK field '${r.RelatedEntityJoinField}' no longer exists) */
-   DELETE FROM ${this.qs(mj_core_schema(), 'EntityRelationship')} WHERE ${this.qi('ID')} = '${r.ID}';
+   DELETE FROM ${this.qs(MjCoreSchema(), 'EntityRelationship')} WHERE ${this.qi('ID')} = '${r.ID}';
 `;
             }
-            await this.LogSQLAndExecute(pool, deleteSQL, 'Remove stale One-To-Many EntityRelationships');
+            await this.logSQLAndExecute(pool, deleteSQL, 'Remove stale One-To-Many EntityRelationships');
         }
     }
     /**
@@ -3388,7 +3513,7 @@ export class ManageMetadataBase {
      */
     async checkAndRemoveMetadataForDeletedTables(pool, excludeSchemas) {
         try {
-            const sql = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntitiesWithMissingBaseTables')}${this.dbProvider.getEntitiesWithMissingBaseTablesFilter()}`;
+            const sql = `SELECT * FROM ${this.qs(MjCoreSchema(), 'vwEntitiesWithMissingBaseTables')}${this.dbProvider.getEntitiesWithMissingBaseTablesFilter()}`;
             const entitiesResult = await this.runQuery(pool, sql);
             const entities = entitiesResult.recordset;
             if (entities && entities.length > 0) {
@@ -3411,8 +3536,8 @@ export class ManageMetadataBase {
                         // discardResult: this routine only performs deletions — nothing below reads rows
                         // from it — and on PostgreSQL it is declared RETURNS SETOF record, which cannot be
                         // invoked through the default `SELECT * FROM` form at all.
-                        const sqlDelete = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spDeleteEntityWithCoreDependencies', [`'${e.ID}'`], ['EntityID'], true);
-                        await this.LogSQLAndExecute(pool, sqlDelete, `SQL text to remove entity ${e.Name}`);
+                        const sqlDelete = this.dbProvider.callRoutineSQL(MjCoreSchema(), 'spDeleteEntityWithCoreDependencies', [`'${e.ID}'`], ['EntityID'], true);
+                        await this.logSQLAndExecute(pool, sqlDelete, `SQL text to remove entity ${e.Name}`);
                         logStatus(`      > Removed metadata for table ${e.SchemaName}.${e.BaseTable}`);
                         // Recorded only after the delete succeeds, so a failed removal (logged below for
                         // an admin to handle) does not mark a schema dirty for an entity still present.
@@ -3449,9 +3574,9 @@ export class ManageMetadataBase {
                 // Object type codes: P = Stored Procedure, V = View, FN = Scalar Function, IF/TF = Table-Valued Function
                 const upperType = type.toUpperCase();
                 const sqlDelete = this.dbProvider.dropObjectSQL(upperType, schemaName, name);
-                await this.LogSQLAndExecute(pool, sqlDelete, `SQL text to remove ${type} ${schemaName}.${name}`);
+                await this.logSQLAndExecute(pool, sqlDelete, `SQL text to remove ${type} ${schemaName}.${name}`);
                 // next up, we need to clean up the cache of saved DB objects that may exist for this entity in the appropriate sub-directory.
-                const sqlOutputDir = outputDir('SQL', true);
+                const sqlOutputDir = OutputDir('SQL', true);
                 if (sqlOutputDir) {
                     // now do the same thing for the /schema directory within the provided directory
                     const fType = type === 'procedure' ? 'sp' : type === 'view' ? 'view' : 'full_text_search_function';
@@ -3525,7 +3650,7 @@ export class ManageMetadataBase {
      *   which is the typical "no schema changes since last run" case in Pass 2.
      *   `undefined` (default) preserves prior full-scan behavior.
      */
-    async manageEntityFields(pool, excludeSchemas, skipCreatedAtUpdatedAtDeletedAtFieldValidation, skipEntityFieldValues, currentUser, skipAdvancedGeneration, skipDeleteUnneededFields = false, entityFilter) {
+    async ManageEntityFields(pool, excludeSchemas, skipCreatedAtUpdatedAtDeletedAtFieldValidation, skipEntityFieldValues, currentUser, skipAdvancedGeneration, skipDeleteUnneededFields = false, entityFilter) {
         let bSuccess = true;
         const startTime = new Date();
         // Fast-exit: an explicit empty filter means "no entities changed in Pass 1, so Pass 2 has nothing to do"
@@ -3578,9 +3703,9 @@ export class ManageMetadataBase {
         // Fix: derive virtual field AllowsNull from the FK column that drives the JOIN.
         // The virtual field name = FK field name minus trailing "ID" (e.g. ClassID → Class).
         if (this.dbProvider.NeedsVirtualFieldNullabilityFix) {
-            const fixSQL = this.dbProvider.getFixVirtualFieldNullabilitySQL(mj_core_schema());
+            const fixSQL = this.dbProvider.getFixVirtualFieldNullabilitySQL(MjCoreSchema());
             if (fixSQL) {
-                await this.LogSQLAndExecute(pool, fixSQL, 'SQL to fix virtual field nullability');
+                await this.logSQLAndExecute(pool, fixSQL, 'SQL to fix virtual field nullability');
             }
         }
         // AN: 14-June-2025 - we are now running this AFTER we create new entity fields from schema
@@ -3649,17 +3774,37 @@ export class ManageMetadataBase {
         // Advanced Generation - Smart field identification and form layout
         if (!skipAdvancedGeneration) {
             const step7StartTime = new Date();
-            startSpinner('Applying AI-powered advanced generation (smart fields, form layout)...');
+            StartSpinner('Applying AI-powered advanced generation (smart fields, form layout)...');
             if (!await this.applyAdvancedGeneration(pool, excludeSchemas, currentUser)) {
                 logError('Error applying advanced generation features');
                 // Don't fail the entire process - advanced generation is optional
             }
             const step7Elapsed = ((new Date().getTime() - step7StartTime.getTime()) / 1000).toFixed(1);
-            succeedSpinner(`Advanced generation completed (${step7Elapsed}s)`);
+            SucceedSpinner(`Advanced generation completed (${step7Elapsed}s)`);
+        }
+        // Deterministic search-flag hygiene. Deliberately OUTSIDE the `skipAdvancedGeneration`
+        // guard above: advanced generation is off by default, and an entity created under that
+        // default is precisely the one that ends up flagged searchable with nothing searchable on
+        // it. Ordered after it so the model's choices, where it did run, are already applied and
+        // the seed only fills a genuine gap. See buildSearchFlagHygieneSQL.
+        if (!await this.applySearchFlagHygiene(pool, excludeSchemas)) {
+            logError('Error applying search flag hygiene');
+            // FATAL, unlike advanced generation. This pass compares before it writes, so a failure
+            // means the probes could not run — and because nothing is written in that case, the pass
+            // failing is indistinguishable from the pass having nothing to do: no SQL, no artifact,
+            // every gate green. Advanced generation can degrade quietly because it only ever ADDS
+            // model-suggested metadata; this one turns search OFF on entities and is the only thing
+            // keeping AllowUserSearchAPI honest, so a run where it did not execute must not be
+            // reported as a clean run.
+            bSuccess = false;
         }
         logStatus(`      Total time to manage entity fields: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
         return bSuccess;
     }
+    /** @deprecated Use {@link ManageEntityFields}. */
+    async manageEntityFields(pool, excludeSchemas, skipCreatedAtUpdatedAtDeletedAtFieldValidation, skipEntityFieldValues, currentUser, skipAdvancedGeneration, skipDeleteUnneededFields = false, entityFilter) {
+        return this.ManageEntityFields(pool, excludeSchemas, skipCreatedAtUpdatedAtDeletedAtFieldValidation, skipEntityFieldValues, currentUser, skipAdvancedGeneration, skipDeleteUnneededFields, entityFilter);
+    }
     /**
      * This method ensures that the __mj_DeletedAt field exists in each entity that has DeleteType=Soft. If the field does not exist, it is created.
      */
@@ -3668,7 +3813,7 @@ export class ManageMetadataBase {
             const sqlEntities = `SELECT
                                  *
                               FROM
-                                 ${this.qs(mj_core_schema(), 'vwEntities')}
+                                 ${this.qs(MjCoreSchema(), 'vwEntities')}
                               WHERE
                                  VirtualEntity=${this.boolLit(false)} AND
                                  DeleteType='Soft' AND
@@ -3729,7 +3874,7 @@ export class ManageMetadataBase {
             }
             let totalPKs = 0;
             let totalFKs = 0;
-            const schema = mj_core_schema();
+            const schema = MjCoreSchema();
             // Config supports two formats:
             //   1. Schema-as-key (template format): { "dbo": [{ "TableName": "Orders", ... }] }
             //   2. Flat tables array (legacy format): { "tables": [{ "SchemaName": "dbo", "TableName": "Orders", ... }] }
@@ -3768,7 +3913,7 @@ export class ManageMetadataBase {
                                     ${this.qi('IsPrimaryKey')} = ${this.boolLit(true)},
                                     ${this.qi('IsSoftPrimaryKey')} = ${this.boolLit(true)}
                                 WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = '${pk.FieldName}'`;
-                        const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft PK for ${tableSchema}.${tableName}.${pk.FieldName}`);
+                        const result = await this.logSQLAndExecute(pool, sSQL, `Set soft PK for ${tableSchema}.${tableName}.${pk.FieldName}`);
                         if (result !== null) {
                             logStatus(`         ✓ Set IsPrimaryKey=1, IsSoftPrimaryKey=1 for ${tableName}.${pk.FieldName}`);
                             totalPKs++;
@@ -3812,7 +3957,7 @@ export class ManageMetadataBase {
                                     ${this.qi('IsSoftForeignKey')} = ${this.boolLit(true)},
                                     ${this.qi('AutoUpdateRelatedEntityInfo')} = ${this.boolLit(false)}
                                 WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = '${fk.FieldName}'`;
-                        const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft FK for ${tableSchema}.${tableName}.${fk.FieldName} → ${fk.RelatedTable}.${fk.RelatedField}`);
+                        const result = await this.logSQLAndExecute(pool, sSQL, `Set soft FK for ${tableSchema}.${tableName}.${fk.FieldName} → ${fk.RelatedTable}.${fk.RelatedField}`);
                         if (result !== null) {
                             logStatus(`         ✓ Set soft FK for ${tableName}.${fk.FieldName} → ${fk.RelatedTable}.${fk.RelatedField}`);
                             totalFKs++;
@@ -3843,7 +3988,7 @@ export class ManageMetadataBase {
             return true;
         try {
             // Load all existing EntityFieldValue rows for dedup checking
-            const efvSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityFieldValue')} ORDER BY EntityFieldID, Sequence, Value, ID`;
+            const efvSQL = `SELECT * FROM ${this.qs(MjCoreSchema(), 'EntityFieldValue')} ORDER BY EntityFieldID, Sequence, Value, ID`;
             const allEFVResult = await this.runQuery(pool, efvSQL);
             const allEntityFieldValues = allEFVResult.recordset;
             let totalApplied = 0;
@@ -3869,7 +4014,7 @@ export class ManageMetadataBase {
      * EntityFieldValue rows already exist (from CHECK constraints) and skips if so.
      */
     async applyValueListsForTable(pool, schemaName, tableName, fields, allEntityFieldValues) {
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         let applied = 0;
         let skipped = 0;
         // Look up entity ID
@@ -3915,7 +4060,7 @@ export class ManageMetadataBase {
         const newType = fieldCfg.ValueListType;
         if (currentValueListType !== newType.toLowerCase()) {
             const updateSQL = `UPDATE ${this.qs(schema, 'EntityField')} SET ValueListType='${newType}' WHERE ID='${entityFieldID}'`;
-            await this.LogSQLAndExecute(pool, updateSQL, `Set soft ValueListType='${newType}' for ${schemaName}.${tableName}.${fieldCfg.FieldName}`);
+            await this.logSQLAndExecute(pool, updateSQL, `Set soft ValueListType='${newType}' for ${schemaName}.${tableName}.${fieldCfg.FieldName}`);
         }
         logStatus(`         ✓ Applied soft value-list for ${tableName}.${fieldCfg.FieldName} (${sortedValues.length} values, type=${newType})`);
         return 'applied';
@@ -3937,7 +4082,7 @@ export class ManageMetadataBase {
             const sqlEntities = `SELECT
                                  *
                               FROM
-                                 ${this.qs(mj_core_schema(), 'vwEntities')}
+                                 ${this.qs(MjCoreSchema(), 'vwEntities')}
                               WHERE
                                  VirtualEntity = ${this.boolLit(false)} AND
                                  ${externalEntityClause}
@@ -4001,7 +4146,7 @@ export class ManageMetadataBase {
                     // and the subsequent UPDATE referencing that column run in separate batches.
                     // SQL Server compiles an entire batch before executing, so without the separator
                     // the UPDATE fails with "Invalid column name" since the column doesn't exist yet at compile time.
-                    await this.LogSQLAndExecute(pool, stmt, `SQL text to add special date field ${fieldName} to entity ${entity.SchemaName}.${entity.BaseTable}`, false, true, this.dbProvider.BatchSeparator);
+                    await this.logSQLAndExecute(pool, stmt, `SQL text to add special date field ${fieldName} to entity ${entity.SchemaName}.${entity.BaseTable}`, false, true, this.dbProvider.BatchSeparator);
                 }
             }
             else {
@@ -4014,7 +4159,7 @@ export class ManageMetadataBase {
                     // modifying the column, and finally adding the default constraint back in.
                     await this.dropExistingDefaultConstraint(pool, entity, fieldName);
                     const sql = this.dbProvider.alterColumnTypeAndNullabilitySQL(entity.SchemaName, entity.BaseTable, fieldName, this.timestampType, allowNull);
-                    await this.LogSQLAndExecute(pool, sql, `SQL text to update special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
+                    await this.logSQLAndExecute(pool, sql, `SQL text to update special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
                     if (!allowNull)
                         await this.createDefaultConstraintForSpecialDateField(pool, entity, fieldName);
                 }
@@ -4044,7 +4189,7 @@ export class ManageMetadataBase {
     async createDefaultConstraintForSpecialDateField(pool, entity, fieldName) {
         try {
             const sqlAddDefaultConstraint = this.dbProvider.addDefaultConstraintSQL(entity.SchemaName, entity.BaseTable, fieldName, this.utcNow());
-            await this.LogSQLAndExecute(pool, sqlAddDefaultConstraint, `SQL text to add default constraint for special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
+            await this.logSQLAndExecute(pool, sqlAddDefaultConstraint, `SQL text to add default constraint for special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
         }
         catch (e) {
             logError(e);
@@ -4071,7 +4216,7 @@ export class ManageMetadataBase {
         try {
             const sqlDropDefaultConstraint = this.dbProvider.dropDefaultConstraintSQL(entity.SchemaName, entity.BaseTable, fieldName);
             // DECLARE-bearing block: close its batch in the replayable log (see SQLLogging.appendToSQLLogFile).
-            await this.LogSQLAndExecute(pool, sqlDropDefaultConstraint, `SQL text to drop default existing default constraints in entity ${entity.SchemaName}.${entity.BaseTable}`, false, true, this.dbProvider.BatchSeparator);
+            await this.logSQLAndExecute(pool, sqlDropDefaultConstraint, `SQL text to drop default existing default constraints in entity ${entity.SchemaName}.${entity.BaseTable}`, false, true, this.dbProvider.BatchSeparator);
         }
         catch (e) {
             logError(e);
@@ -4096,15 +4241,15 @@ export class ManageMetadataBase {
                 // "Unclosed quotation mark" (SQL Server) at the very end of an otherwise-complete
                 // pass. '' doubling is correct on both supported dialects.
                 const esc = (s) => s.replace(/'/g, "''");
-                const dataResult = await this.runQuery(pool, `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntities')} WHERE Name = '${esc(e)}'`);
+                const dataResult = await this.runQuery(pool, `SELECT * FROM ${this.qs(MjCoreSchema(), 'vwEntities')} WHERE Name = '${esc(e)}'`);
                 const data = dataResult.recordset;
-                const fieldsResult = await this.runQuery(pool, `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntityFields')} WHERE EntityID='${data[0].ID}'`);
+                const fieldsResult = await this.runQuery(pool, `SELECT * FROM ${this.qs(MjCoreSchema(), 'vwEntityFields')} WHERE EntityID='${data[0].ID}'`);
                 const fields = fieldsResult.recordset;
                 // Use new API to generate entity description
                 const result = await ag.generateEntityDescription(e, data[0].BaseTable, fields.map((f) => ({ Name: f.Name, Type: f.Type, IsNullable: f.AllowsNull, Description: f.Description })), currentUser);
                 if (result?.entityDescription && result.entityDescription.length > 0) {
-                    const sSQL = `UPDATE ${this.qs(mj_core_schema(), 'Entity')} SET ${this.qi('Description')} = '${esc(result.entityDescription)}', ${this.qi('AutoUpdateDescription')} = ${this.boolLit(false)} WHERE ${this.qi('Name')} = '${esc(e)}'`;
-                    await this.LogSQLAndExecute(pool, sSQL, `SQL text to update entity description for entity ${e}`);
+                    const sSQL = `UPDATE ${this.qs(MjCoreSchema(), 'Entity')} SET ${this.qi('Description')} = '${esc(result.entityDescription)}', ${this.qi('AutoUpdateDescription')} = ${this.boolLit(false)} WHERE ${this.qi('Name')} = '${esc(e)}'`;
+                    await this.logSQLAndExecute(pool, sSQL, `SQL text to update entity description for entity ${e}`);
                 }
                 else {
                     console.warn('   >>> Advanced Generation Error: LLM returned invalid result, skipping entity description for entity ' + e);
@@ -4125,9 +4270,9 @@ export class ManageMetadataBase {
             const sql = `SELECT
                         ef.ID, ef.Name
                       FROM
-                        ${this.qs(mj_core_schema(), 'vwEntityFields')} ef
+                        ${this.qs(MjCoreSchema(), 'vwEntityFields')} ef
                       INNER JOIN
-                        ${this.qs(mj_core_schema(), 'vwEntities')} e
+                        ${this.qs(MjCoreSchema(), 'vwEntities')} e
                       ON
                         ef.EntityID = e.ID
                       WHERE
@@ -4142,8 +4287,8 @@ export class ManageMetadataBase {
                     const namingOptions = configInfo.entityNaming?.normalizeFieldNames !== false ? this.getEntityNamingOptions() : undefined;
                     const sDisplayName = stripTrailingChars(createDisplayName(field.Name, namingOptions), 'ID', true).trim();
                     if (sDisplayName.length > 0 && sDisplayName.toLowerCase().trim() !== field.Name.toLowerCase().trim()) {
-                        const sSQL = `UPDATE ${this.qs(mj_core_schema(), 'EntityField')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()}, DisplayName = '${sDisplayName}' WHERE ID = '${field.ID}'`;
-                        await this.LogSQLAndExecute(pool, sSQL, `SQL text to update display name for field ${field.Name}`);
+                        const sSQL = `UPDATE ${this.qs(MjCoreSchema(), 'EntityField')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()}, DisplayName = '${sDisplayName}' WHERE ID = '${field.ID}'`;
+                        await this.logSQLAndExecute(pool, sSQL, `SQL text to update display name for field ${field.Name}`);
                     }
                 }
             return true;
@@ -4163,12 +4308,12 @@ export class ManageMetadataBase {
      */
     async setDefaultColumnWidthWhereNeeded(pool, excludeSchemas) {
         try {
-            const heal = buildHealSchemaRoutineParams({
-                authoredExclude: getAuthoredExcludeSchemas(excludeSchemas),
+            const heal = BuildHealSchemaRoutineParams({
+                authoredExclude: GetAuthoredExcludeSchemas(excludeSchemas),
                 includeSchemas: configInfo.includeSchemas,
             });
-            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spSetDefaultColumnWidthWhereNeeded', heal.values, heal.names);
-            await this.LogSQLAndExecute(pool, sSQL, `SQL text to set default column width where needed`, true);
+            const sSQL = this.dbProvider.callRoutineSQL(MjCoreSchema(), 'spSetDefaultColumnWidthWhereNeeded', heal.Values, heal.Names);
+            await this.logSQLAndExecute(pool, sSQL, `SQL text to set default column width where needed`, true);
             return true;
         }
         catch (e) {
@@ -4188,7 +4333,7 @@ export class ManageMetadataBase {
      * @returns {string} - The SQL statement to retrieve pending entity fields.
      */
     getPendingEntityFieldsSELECTSQL(entityIDs, excludeSchemas) {
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         return this.dbProvider.getPendingEntityFieldsSQL(schema, entityIDs, excludeSchemas);
     }
     /**
@@ -4231,7 +4376,7 @@ export class ManageMetadataBase {
         const quotedDefaultValue = (parsedDefaultValue == null || parsedDefaultValue.trim().length === 0)
             ? 'NULL'
             : (parsedDefaultValue.trim().toLowerCase() === 'null' ? 'NULL' : `'${escapedParsedDefault}'`);
-        const conflictCheck = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID = '${newEntityFieldUUID}' OR (EntityID = '${n.EntityID}' AND Name = '${n.FieldName}')`;
+        const conflictCheck = `SELECT 1 FROM ${this.qs(MjCoreSchema(), 'EntityField')} WHERE ID = '${newEntityFieldUUID}' OR (EntityID = '${n.EntityID}' AND Name = '${n.FieldName}')`;
         const guard = this.dbProvider.wrapInsertWithConflictGuard(conflictCheck);
         // Sequence is an apply-time expression, never a literal: see applyTimeEntityFieldSequenceSQL.
         // `n.Sequence` (MAX+100000+ordinal from the pending SELECT) is only that query's ORDER BY key
@@ -4239,7 +4384,7 @@ export class ManageMetadataBase {
         const sequenceExpr = this.applyTimeEntityFieldSequenceSQL(n.EntityID);
         return `
       ${guard.prefix}
-         INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')}
+         INSERT INTO ${this.qs(MjCoreSchema(), 'EntityField')}
          (
             ${this.qi('ID')},
             ${this.qi('EntityID')},
@@ -4354,7 +4499,7 @@ export class ManageMetadataBase {
                     for (let i = 0; i < inserts.length; i += CHUNK_SIZE) {
                         const chunk = inserts.slice(i, i + CHUNK_SIZE);
                         try {
-                            await this.LogSQLBatchAndExecute(pool, chunk, `SQL text to insert ${chunk.length} new entity field(s)`);
+                            await this.logSQLBatchAndExecute(pool, chunk, `SQL text to insert ${chunk.length} new entity field(s)`);
                             // an error blows up the transaction (all-or-nothing), which is what we want
                         }
                         catch (e) {
@@ -4388,10 +4533,10 @@ export class ManageMetadataBase {
      * @param relatedEntityNameFieldMap
      * @returns
      */
-    async updateEntityFieldRelatedEntityNameFieldMap(pool, entityFieldID, relatedEntityNameFieldMap) {
+    async UpdateEntityFieldRelatedEntityNameFieldMap(pool, entityFieldID, relatedEntityNameFieldMap) {
         try {
-            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateEntityFieldRelatedEntityNameFieldMap', [`'${entityFieldID}'`, `'${relatedEntityNameFieldMap}'`], ['EntityFieldID', 'RelatedEntityNameFieldMap']);
-            await this.LogSQLAndExecute(pool, sSQL, `SQL text to update entity field related entity name field map for entity field ID ${entityFieldID}`);
+            const sSQL = this.dbProvider.callRoutineSQL(MjCoreSchema(), 'spUpdateEntityFieldRelatedEntityNameFieldMap', [`'${entityFieldID}'`, `'${relatedEntityNameFieldMap}'`], ['EntityFieldID', 'RelatedEntityNameFieldMap']);
+            await this.logSQLAndExecute(pool, sSQL, `SQL text to update entity field related entity name field map for entity field ID ${entityFieldID}`);
             return true;
         }
         catch (e) {
@@ -4399,14 +4544,18 @@ export class ManageMetadataBase {
             return false;
         }
     }
+    /** @deprecated Use {@link UpdateEntityFieldRelatedEntityNameFieldMap}. */
+    async updateEntityFieldRelatedEntityNameFieldMap(pool, entityFieldID, relatedEntityNameFieldMap) {
+        return this.UpdateEntityFieldRelatedEntityNameFieldMap(pool, entityFieldID, relatedEntityNameFieldMap);
+    }
     async updateExistingEntitiesFromSchema(pool, excludeSchemas) {
         try {
-            const heal = buildHealSchemaRoutineParams({
-                authoredExclude: getAuthoredExcludeSchemas(excludeSchemas),
+            const heal = BuildHealSchemaRoutineParams({
+                authoredExclude: GetAuthoredExcludeSchemas(excludeSchemas),
                 includeSchemas: configInfo.includeSchemas,
             });
-            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateExistingEntitiesFromSchema', heal.values, heal.names);
-            const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to update existing entities from schema`, true);
+            const sSQL = this.dbProvider.callRoutineSQL(MjCoreSchema(), 'spUpdateExistingEntitiesFromSchema', heal.Values, heal.Names);
+            const result = await this.logSQLAndExecute(pool, sSQL, `SQL text to update existing entities from schema`, true);
             // result contains the updated entities, and there is a property of each row called Name which has the entity name that was modified
             // add these to the modified entity list if they're not already in there
             if (result && result.length > 0) {
@@ -4422,30 +4571,34 @@ export class ManageMetadataBase {
     /**
      * Adds a list of entity names to the modified entity list if they're not already in there
      */
-    static addNewEntitiesToModifiedList(entityNames) {
+    static AddNewEntitiesToModifiedList(entityNames) {
         const distinctEntityNames = [...new Set(entityNames)];
         const newlyModifiedEntityNames = distinctEntityNames.filter((e) => !ManageMetadataBase._modifiedEntityList.includes(e));
         // now make sure that each of these entity names is in the modified entity list
         ManageMetadataBase._modifiedEntityList = ManageMetadataBase._modifiedEntityList.concat(newlyModifiedEntityNames);
     }
+    /** @deprecated Use {@link AddNewEntitiesToModifiedList}. */
+    static addNewEntitiesToModifiedList(entityNames) {
+        return this.AddNewEntitiesToModifiedList(entityNames);
+    }
     async updateExistingEntityFieldsFromSchema(pool, excludeSchemas, entityIDs) {
         try {
             // One SP call regardless of scope: pass the entire entity ID list as a comma-delimited
             // string (mirrors the @ExcludedSchemaNames pattern). The SP fans the list out into
             // a table variable via STRING_SPLIT and joins once. This avoids both per-entity
             // round-trips (slow) and parallel calls (page-level lock contention on EntityField).
-            const heal = buildHealSchemaRoutineParams({
-                authoredExclude: getAuthoredExcludeSchemas(excludeSchemas),
+            const heal = BuildHealSchemaRoutineParams({
+                authoredExclude: GetAuthoredExcludeSchemas(excludeSchemas),
                 includeSchemas: configInfo.includeSchemas,
                 entityIDs,
             });
-            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateExistingEntityFieldsFromSchema', heal.values, heal.names);
+            const sSQL = this.dbProvider.callRoutineSQL(MjCoreSchema(), 'spUpdateExistingEntityFieldsFromSchema', heal.Values, heal.Names);
             const isScoped = entityIDs !== undefined && entityIDs.length > 0;
             const label = isScoped
                 ? `SQL text to update existing entity fields from schema (${entityIDs.length} scoped entities)`
                 : `SQL text to update existing entity fields from schema`;
             const before = await this.snapshotEntityFields(pool, entityIDs);
-            await this.LogSQLAndExecute(pool, sSQL, label, true);
+            await this.logSQLAndExecute(pool, sSQL, label, true);
             const after = await this.snapshotEntityFields(pool, entityIDs);
             const changes = diffEntityFieldSnapshots(before, after, (e, n) => ManageMetadataBase.isFieldNew(e, n));
             if (changes.length > 0) {
@@ -4476,12 +4629,12 @@ export class ManageMetadataBase {
      */
     async updateSchemaInfoFromDatabase(pool, excludeSchemas) {
         try {
-            const heal = buildHealSchemaRoutineParams({
-                authoredExclude: getAuthoredExcludeSchemas(excludeSchemas),
+            const heal = BuildHealSchemaRoutineParams({
+                authoredExclude: GetAuthoredExcludeSchemas(excludeSchemas),
                 includeSchemas: configInfo.includeSchemas,
             });
-            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateSchemaInfoFromDatabase', heal.values, heal.names);
-            const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to sync schema info from database schemas`, true);
+            const sSQL = this.dbProvider.callRoutineSQL(MjCoreSchema(), 'spUpdateSchemaInfoFromDatabase', heal.Values, heal.Names);
+            const result = await this.logSQLAndExecute(pool, sSQL, `SQL text to sync schema info from database schemas`, true);
             if (result && result.length > 0) {
                 logStatus(`   > Updated/created ${result.length} SchemaInfo records`);
                 this.cacheSchemaInfoRecords(result);
@@ -4511,7 +4664,7 @@ export class ManageMetadataBase {
      */
     async loadSchemaInfoRecords(pool) {
         try {
-            const sSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'SchemaInfo')}`;
+            const sSQL = `SELECT * FROM ${this.qs(MjCoreSchema(), 'SchemaInfo')}`;
             const result = await this.runQuery(pool, sSQL);
             if (result?.recordset?.length > 0) {
                 this.cacheSchemaInfoRecords(result.recordset);
@@ -4577,17 +4730,17 @@ export class ManageMetadataBase {
             // string (mirrors the @ExcludedSchemaNames pattern). The SP fans the list out into
             // a table variable via STRING_SPLIT and filters once. Avoids both per-entity
             // round-trips and parallel calls (page-level lock contention on EntityField).
-            const heal = buildHealSchemaRoutineParams({
-                authoredExclude: getAuthoredExcludeSchemas(excludeSchemas),
+            const heal = BuildHealSchemaRoutineParams({
+                authoredExclude: GetAuthoredExcludeSchemas(excludeSchemas),
                 includeSchemas: configInfo.includeSchemas,
                 entityIDs,
             });
-            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spDeleteUnneededEntityFields', heal.values, heal.names);
+            const sSQL = this.dbProvider.callRoutineSQL(MjCoreSchema(), 'spDeleteUnneededEntityFields', heal.Values, heal.Names);
             const isScoped = entityIDs !== undefined && entityIDs.length > 0;
             const label = isScoped
                 ? `SQL text to delete unneeded entity fields (${entityIDs.length} scoped entities)`
                 : `SQL text to delete unneeded entity fields`;
-            const result = await this.LogSQLAndExecute(pool, sSQL, label, true);
+            const result = await this.logSQLAndExecute(pool, sSQL, label, true);
             // result contains the DELETED entity fields. Get a distinct list of entity names
             // and add them to the modified entity list if they're not already in there.
             if (result && result.length > 0) {
@@ -4607,13 +4760,13 @@ export class ManageMetadataBase {
             // for the field and sync that up with the EntityFieldValue table. If it is not a simple series of OR statements, we will not be able to parse it and we'll
             // just ignore it.
             const filter = this.dbProvider.getCheckConstraintsSchemaFilter(excludeSchemas);
-            const sSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntityFieldsWithCheckConstraints')}${filter}`;
+            const sSQL = `SELECT * FROM ${this.qs(MjCoreSchema(), 'vwEntityFieldsWithCheckConstraints')}${filter}`;
             const resultResult = await this.runQuery(pool, sSQL);
             const result = resultResult.recordset;
-            const efvSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityFieldValue')} ORDER BY EntityFieldID, Sequence, Value, ID`;
+            const efvSQL = `SELECT * FROM ${this.qs(MjCoreSchema(), 'EntityFieldValue')} ORDER BY EntityFieldID, Sequence, Value, ID`;
             const allEntityFieldValuesResult = await this.runQuery(pool, efvSQL);
             const allEntityFieldValues = allEntityFieldValuesResult.recordset;
-            const efSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntityFields')} ORDER BY EntityID, Sequence, Name, ID`;
+            const efSQL = `SELECT * FROM ${this.qs(MjCoreSchema(), 'vwEntityFields')} ORDER BY EntityID, Sequence, Name, ID`;
             const allEntityFieldsResult = await this.runQuery(pool, efSQL);
             const allEntityFields = allEntityFieldsResult.recordset;
             const generationPromises = [];
@@ -4631,25 +4784,30 @@ export class ManageMetadataBase {
             for (const r of columnLevelResults) {
                 // now, for each of the constraints we get back here, loop through and evaluate if they're simple and if they're simple, parse and sync with entity field values for that field
                 if (r.ConstraintDefinition && r.ConstraintDefinition.length > 0) {
-                    const parsedValues = this.parseCheckConstraintValues(r.ConstraintDefinition, r.ColumnName, r.EntityName);
+                    // parse first, then decide whether THIS field should carry the list (bit, PK singleton guards).
+                    // UUIDsEqual, not ===: PG returns lowercase UUIDs and SQL Server uppercase, and a missed
+                    // lookup here fails OPEN (the exclusions stop applying), so a case mismatch would be silent.
+                    const field = allEntityFields.find((f) => UUIDsEqual(f.ID, r.EntityFieldID));
+                    const parsedValues = ManageMetadataBase.valueListForField(field, this.parseCheckConstraintValues(r.ConstraintDefinition, r.ColumnName, r.EntityName));
                     if (parsedValues) {
                         if (!skipDBUpdate) {
                             // we only do this part if we are not skiping the database update as this code will sync values from the CHECK
                             // with the EntityFieldValues in the database.
-                            // Sort values alphabetically to ensure consistent sequences across all databases
-                            // This guarantees the same value always gets the same sequence number regardless of
-                            // how SQL Server returns CHECK constraint values (which can vary)
-                            parsedValues.sort();
+                            // Sort the values to ensure consistent sequences across all databases. This guarantees the
+                            // same value always gets the same sequence number regardless of how SQL Server returns
+                            // CHECK constraint values (which can vary). An all-numeric list sorts numerically so the
+                            // dropdown reads 1, 2, 10 rather than the lexical 1, 10, 2 — still fully deterministic.
+                            ManageMetadataBase.sortCheckConstraintValues(parsedValues);
                             // we have parsed values from the check constraint, so sync them with the entity field values
                             await this.syncEntityFieldValues(pool, r.EntityFieldID, parsedValues, allEntityFieldValues);
                             // finally, make sure the ValueListType column within the EntityField table is set to "List" because for check constraints we only allow the values specified in the list.
                             // check to see if the ValueListType is already set to "List", if not, update it
-                            const sSQLCheck = `SELECT ValueListType FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID='${r.EntityFieldID}'`;
+                            const sSQLCheck = `SELECT ValueListType FROM ${this.qs(MjCoreSchema(), 'EntityField')} WHERE ID='${r.EntityFieldID}'`;
                             const checkResultResult = await this.runQuery(pool, sSQLCheck);
                             const checkResult = checkResultResult.recordset;
                             if (checkResult && checkResult.length > 0 && checkResult[0].ValueListType.trim().toLowerCase() !== 'list') {
-                                const sSQL = `UPDATE ${this.qs(mj_core_schema(), 'EntityField')} SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
-                                await this.LogSQLAndExecute(pool, sSQL, `SQL text to update ValueListType for entity field ID ${r.EntityFieldID}`);
+                                const sSQL = `UPDATE ${this.qs(MjCoreSchema(), 'EntityField')} SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
+                                await this.logSQLAndExecute(pool, sSQL, `SQL text to update ValueListType for entity field ID ${r.EntityFieldID}`);
                             }
                         }
                         else {
@@ -4691,7 +4849,7 @@ export class ManageMetadataBase {
      * @param pool
      * @param currentUser
      */
-    async loadGeneratedCode(pool, currentUser) {
+    async LoadGeneratedCode(pool, currentUser) {
         try {
             // right now we're just doing validator functions which are handled here
             return await this.manageEntityFieldValuesAndValidatorFunctions(pool, [], currentUser, true);
@@ -4701,6 +4859,10 @@ export class ManageMetadataBase {
             return false;
         }
     }
+    /** @deprecated Use {@link LoadGeneratedCode}. */
+    async loadGeneratedCode(pool, currentUser) {
+        return this.LoadGeneratedCode(pool, currentUser);
+    }
     async runValidationGeneration(r, allEntityFields, generateNewCode, currentUser) {
         const generatedFunction = await this.generateValidatorFunctionFromCheckConstraint(r, allEntityFields, currentUser, generateNewCode);
         if (generatedFunction?.success) {
@@ -4781,8 +4943,8 @@ export class ManageMetadataBase {
                 for (const ev of existingValues) {
                     if (!possibleValues.find(v => v === ev.Value)) {
                         // delete the value from the database
-                        const sSQLDelete = `DELETE FROM ${this.qs(mj_core_schema(), 'EntityFieldValue')} WHERE ID='${ev.ID}'`;
-                        await this.LogSQLAndExecute(ds, sSQLDelete, `SQL text to delete entity field value ID ${ev.ID}`);
+                        const sSQLDelete = `DELETE FROM ${this.qs(MjCoreSchema(), 'EntityFieldValue')} WHERE ID='${ev.ID}'`;
+                        await this.logSQLAndExecute(ds, sSQLDelete, `SQL text to delete entity field value ID ${ev.ID}`);
                         numRemoved++;
                     }
                 }
@@ -4793,11 +4955,11 @@ export class ManageMetadataBase {
                         // Generate a UUID for this new EntityFieldValue record
                         const newId = uuidv4();
                         // add the value to the database with explicit ID
-                        const sSQLInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityFieldValue')}
+                        const sSQLInsert = `INSERT INTO ${this.qs(MjCoreSchema(), 'EntityFieldValue')}
                                        (${this.qi('ID')}, ${this.qi('EntityFieldID')}, ${this.qi('Sequence')}, ${this.qi('Value')}, ${this.qi('Code')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')})
                                     VALUES
                                        ('${newId}', '${entityFieldID}', ${1 + possibleValues.indexOf(v)}, '${v}', '${v}', ${this.utcNow()}, ${this.utcNow()})`;
-                        await this.LogSQLAndExecute(ds, sSQLInsert, `SQL text to insert entity field value with ID ${newId}`);
+                        await this.logSQLAndExecute(ds, sSQLInsert, `SQL text to insert entity field value with ID ${newId}`);
                         numAdded++;
                     }
                 }
@@ -4809,8 +4971,8 @@ export class ManageMetadataBase {
                     //       DB returns a string for Sequence instead of a number.
                     if (ev && ev.Sequence != 1 + possibleValues.indexOf(v)) {
                         // update the sequence to match the order in the possible values list, if it doesn't already match
-                        const sSQLUpdate = `UPDATE ${this.qs(mj_core_schema(), 'EntityFieldValue')} SET Sequence=${1 + possibleValues.indexOf(v)} WHERE ID='${ev.ID}'`;
-                        await this.LogSQLAndExecute(ds, sSQLUpdate, `SQL text to update entity field value sequence`);
+                        const sSQLUpdate = `UPDATE ${this.qs(MjCoreSchema(), 'EntityFieldValue')} SET Sequence=${1 + possibleValues.indexOf(v)} WHERE ID='${ev.ID}'`;
+                        await this.logSQLAndExecute(ds, sSQLUpdate, `SQL text to update entity field value sequence`);
                         numUpdated++;
                     }
                 }
@@ -4827,10 +4989,24 @@ export class ManageMetadataBase {
             return false;
         }
     }
+    /**
+     * Parses a column-level CHECK constraint into the list of values it permits, or returns null when the
+     * constraint is not a simple value list (a range, a `LEN()` predicate, a mixed condition, and so on).
+     *
+     * Both of the ways `IN (...)` is rendered by SQL Server are handled. String, date and GUID literals come
+     * back quoted — `([Status]='Active' OR [Status]='Inactive')` — but numeric and `bit` literals come back
+     * **unquoted and parenthesized**: `([Level]=(3) OR [Level]=(2) OR [Level]=(1))`. Matching only the quoted
+     * form left a numeric IN-list with no value list at all, and so no dropdown in Explorer either (#3978).
+     * PostgreSQL's `= ANY (ARRAY[...])` rendering is handled separately, by parsePgArrayConstraint.
+     *
+     * A single-value list is captured too: `CHECK (Status='Active')` — which is also how SQL Server renders
+     * `IN ('Active')` — permits exactly one value, which is a one-item list.
+     *
+     * This is a parser, not a policy: it reports what the constraint permits. WHICH fields get a value list
+     * out of that is decided after the fact, by valueListForField.
+     */
     parseCheckConstraintValues(constraintDefinition, fieldName, entityName) {
-        // This regex checks for the overall structure including field name and 'OR' sequences
-        // SQL Server uses [FieldName]='Value' quoting, PostgreSQL uses "FieldName" or unquoted FieldName
-        // We handle both: [FieldName], "FieldName", or bare FieldName
+        // Normalize N'literal' to 'literal' so one pattern handles both.
         // Note: Assuming fieldName does not contain regex special characters; otherwise, it needs to be escaped as well.
         const processedConstraint = constraintDefinition.replace(/(^|[=(\s])N'([^']*)'/g, "$1'$2'");
         // PostgreSQL ANY (ARRAY[...]) pattern:
@@ -4843,46 +5019,92 @@ export class ManageMetadataBase {
         // Build a regex fragment that matches the field name in any quoting style:
         // [FieldName] (SQL Server) or "FieldName" (PostgreSQL) or bare FieldName
         const quotedField = `(?:\\[${fieldName}\\]|"${fieldName}"|${fieldName})`;
-        // Check for nested pattern: (Field IS NULL OR (Field='Value1' OR ...))
-        const nestedNullRegex = new RegExp(`^\\(${quotedField} IS NULL OR \\(${quotedField}='[^']+'(?: OR ${quotedField}='[^']+?')+\\)\\)$`);
-        if (nestedNullRegex.test(processedConstraint)) {
-            // Extract values from nested pattern - same extraction logic works
-            const valueRegex = new RegExp(`${quotedField}='([^']+)\'`, 'g');
-            let match;
-            const possibleValues = [];
-            while ((match = valueRegex.exec(processedConstraint)) !== null) {
-                if (match.index === valueRegex.lastIndex) {
-                    valueRegex.lastIndex++;
-                }
-                if (match[1]) {
-                    possibleValues.push(match[1]);
-                }
+        // One literal, either quoting style. The unquoted numeric forms are the ones sys.check_constraints
+        // actually stores: (3) (-1) (1.00) (2.5) (1.0000000000000000e+030) and (12345678901234567890.) —
+        // an integral literal with a trailing point once the precision is large enough.
+        const literal = `(?:'[^']+'|${ManageMetadataBase.NUMERIC_CHECK_LITERAL})`;
+        const assignment = `${quotedField}=${literal}`;
+        // Nested pattern: (Field IS NULL OR (Field=<literal> OR ...)) — how `X IS NULL OR X IN (...)` renders
+        const nestedNullRegex = new RegExp(`^\\(${quotedField} IS NULL OR \\(${assignment}(?: OR ${assignment})*\\)\\)$`);
+        // Standard pattern, with an optional trailing IS NULL: (Field=<literal> OR ... [OR Field IS NULL])
+        const structureRegex = new RegExp(`^\\(${assignment}(?: OR ${assignment})*(?: OR ${quotedField} IS NULL)?\\)$`);
+        if (!nestedNullRegex.test(processedConstraint) && !structureRegex.test(processedConstraint)) {
+            return null;
+        }
+        // Extract the values: group 1 is a quoted literal, group 2 an unquoted numeric one.
+        const valueRegex = new RegExp(`${quotedField}=(?:'([^']+)'|(${ManageMetadataBase.NUMERIC_CHECK_LITERAL}))`, 'g');
+        const possibleValues = [];
+        let match;
+        while ((match = valueRegex.exec(processedConstraint)) !== null) {
+            // This is necessary to avoid infinite loops with zero-width matches
+            if (match.index === valueRegex.lastIndex) {
+                valueRegex.lastIndex++;
+            }
+            const value = match[1] ?? (match[2] ? ManageMetadataBase.normalizeNumericCheckLiteral(match[2]) : undefined);
+            if (value && value.length > 0) {
+                possibleValues.push(value);
             }
-            return possibleValues.length > 0 ? possibleValues : null;
         }
-        // Check for standard pattern with optional trailing IS NULL
-        const structureRegex = new RegExp(`^\\(${quotedField}='[^']+'(?: OR ${quotedField}='[^']+?')+(?: OR ${quotedField} IS NULL)?\\)$`);
-        if (!structureRegex.test(processedConstraint)) {
+        // An empty result is not a value list — returning [] here would set ValueListType='List' on a field
+        // with no EntityFieldValue rows behind it.
+        return possibleValues.length > 0 ? possibleValues : null;
+    }
+    /**
+     * The value list to actually store for a field, or null when a parsed list should NOT become
+     * EntityFieldValue rows (and so should not become a dropdown in Explorer either).
+     *
+     * Runs AFTER parsing rather than gating it, so each exclusion is no broader than its own reason and
+     * neither one can drop a list that was captured before #3978:
+     *
+     * - `bit`: `IN (0,1)` is vacuous — bit already permits exactly 0 and 1 — and `= 1` is a validator,
+     *   not a two-item dropdown over what renders as a checkbox. Every bit list is rendered unquoted, so
+     *   none of them was reachable before this change and nothing regresses.
+     * - a PRIMARY KEY carrying a SINGLE value: `CHECK (ID=1)` is the single-row-table guard MJ's own
+     *   sequence tables use — a structural invariant, not a set of values a user picks from. A
+     *   MULTI-value list on a primary key is left alone: `CHECK (Code IN ('US','CA'))` on a natural-key
+     *   PK is a real domain list, it was captured before this change, and CodeGen also runs over customer
+     *   schemas where natural-key primary keys are ordinary.
+     *
+     * A field whose metadata row was not found keeps whatever parsed, which is the pre-#3978 behaviour.
+     */
+    static valueListForField(field, parsedValues) {
+        if (!parsedValues || !field) {
+            return parsedValues;
+        }
+        if (field.Type?.trim().toLowerCase() === 'bit') {
             return null;
         }
-        else {
-            // Regular expression to match the values within the single quotes specifically for the field
-            const valueRegex = new RegExp(`${quotedField}='([^']+)\'`, 'g');
-            let match;
-            const possibleValues = [];
-            // Use regex to find matches and extract the values
-            while ((match = valueRegex.exec(processedConstraint)) !== null) {
-                // This is necessary to avoid infinite loops with zero-width matches
-                if (match.index === valueRegex.lastIndex) {
-                    valueRegex.lastIndex++;
-                }
-                // The first captured group contains the value
-                if (match[1]) {
-                    possibleValues.push(match[1]);
-                }
-            }
-            return possibleValues;
+        if (field.IsPrimaryKey && parsedValues.length === 1) {
+            return null;
         }
+        return parsedValues;
+    }
+    /**
+     * Sorts a parsed value list in place, so the sequence a value gets is stable across databases and runs.
+     * An all-numeric list is compared as numbers (1, 2, 10); anything else keeps the default lexical order.
+     *
+     * Keyed off the VALUES, not the column type — so a string column whose list happens to be all-numeric
+     * (`CHECK (Code IN ('1','2','10'))` on nvarchar) would re-sequence too. Measured over every column CHECK
+     * constraint in a live 6.x database (MJ core + BizApps accounting/orders): of the 431 lists the previous
+     * parser already captured, ZERO re-sequence under this comparison. If one ever turns up and the churn is
+     * unwanted, gate `allNumeric` on the field being numeric as well.
+     */
+    static sortCheckConstraintValues(values) {
+        const allNumeric = values.length > 0 && values.every(v => /^-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/.test(v));
+        return allNumeric ? values.sort((a, b) => Number(a) - Number(b)) : values.sort();
+    }
+    /**
+     * A numeric literal as SQL Server renders it inside a CHECK constraint: parenthesized, unquoted, and
+     * possibly signed, fractional or exponential — `(3)`, `(-1)`, `(1.00)`, `(2.5)`, `(1.0e+030)`.
+     */
+    static { this.NUMERIC_CHECK_LITERAL = `\\(-?\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?\\)`; }
+    /**
+     * Turns a matched numeric literal into the value to store: strips the wrapping parentheses, and the
+     * trailing point SQL Server adds to a large integral literal (`(12345678901234567890.)`).
+     */
+    static normalizeNumericCheckLiteral(literal) {
+        const inner = literal.slice(1, -1);
+        return inner.endsWith('.') ? inner.slice(0, -1) : inner;
     }
     /**
      * Parses PostgreSQL ANY (ARRAY[...]) CHECK constraint syntax.
@@ -4945,7 +5167,7 @@ export class ManageMetadataBase {
             // it — user-visible AND editable, letting someone mutate the snapshot the refresher overwrites. The
             // wrapper view is already excluded (it carries the minted entity, so EntityID IS NOT NULL). The outer
             // view is aliased `t` so the correlated MaterializedResult subquery can't resolve columns ambiguously.
-            const coreSchema = mj_core_schema();
+            const coreSchema = MjCoreSchema();
             // Gate the MaterializedResult reference on the table actually existing. Referencing it unconditionally
             // would throw — breaking new-entity creation for EVERY entity — on any DB where MaterializedResult
             // isn't present yet (e.g. the PostgreSQL parallel world's object-availability lag). If it's absent we
@@ -5089,7 +5311,7 @@ export class ManageMetadataBase {
         const result = await ag.generateEntityName(newEntity.TableName, currentUser);
         // Checked here as well as inside generateEntityName: a subclass or a stub can return anything, and
         // a non-name that reaches the INSERT fails it (see createNewEntity's catch for why that used to be silent).
-        if (result && isPlausibleEntityName(result.entityName)) {
+        if (result && IsPlausibleEntityName(result.entityName)) {
             return this.markupEntityName(newEntity.SchemaName, result.entityName);
         }
         else {
@@ -5154,7 +5376,7 @@ export class ManageMetadataBase {
         return configInfo.newEntityDefaults?.NameRulesBySchema?.find(r => {
             let schemaNameToUse = r.SchemaName;
             if (schemaNameToUse?.trim().toLowerCase() === '${mj_core_schema}') {
-                schemaNameToUse = mj_core_schema();
+                schemaNameToUse = MjCoreSchema();
             }
             return schemaNameToUse.trim().toLowerCase() === schemaName.trim().toLowerCase();
         });
@@ -5204,7 +5426,7 @@ export class ManageMetadataBase {
                 // process a single new entity
                 let newEntityName = await this.createNewEntityName(newEntity, currentUser);
                 const newEntityDisplayName = this.createNewEntityDisplayName(newEntity, newEntityName);
-                const { name: uniqueName, suffix: uniqueSuffix } = this.resolveUniqueEntityName(newEntityName, newEntity.SchemaName, md.Entities.map(e => e.Name));
+                const { name: uniqueName, suffix: uniqueSuffix } = this.ResolveUniqueEntityName(newEntityName, newEntity.SchemaName, md.Entities.map(e => e.Name));
                 if (uniqueName !== newEntityName) {
                     LogError(`   >>>> WARNING: Entity name already exists, so using ${uniqueName} instead. If you did not intend for this, please rename the ${newEntity.SchemaName}.${newEntity.TableName} table in the database.`);
                 }
@@ -5213,7 +5435,7 @@ export class ManageMetadataBase {
                 const isNewSchema = await this.isSchemaNew(pool, newEntity.SchemaName);
                 const newEntityID = this.createNewUUID();
                 const sSQLInsert = this.createNewEntityInsertSQL(newEntityID, newEntityName, newEntity, suffix, newEntityDisplayName);
-                await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to create new entity ${newEntityName}`);
+                await this.logSQLAndExecute(pool, sSQLInsert, `SQL generated to create new entity ${newEntityName}`);
                 // if we get here we created a new entity safely, otherwise we get exception
                 // add it to the new entity list
                 ManageMetadataBase.newEntityList.push(newEntityName);
@@ -5246,10 +5468,10 @@ export class ManageMetadataBase {
                     if (configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
                         // only do this if the configuration setting is set to add new entities to applications for schema names
                         for (const appUUID of apps) {
-                            const sSQLInsertApplicationEntity = `INSERT INTO ${this.qs(mj_core_schema(), 'ApplicationEntity')}
+                            const sSQLInsertApplicationEntity = `INSERT INTO ${this.qs(MjCoreSchema(), 'ApplicationEntity')}
                                        (${this.qi('ApplicationID')}, ${this.qi('EntityID')}, ${this.qi('Sequence')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')}) VALUES
-                                       ('${appUUID}', '${newEntityID}', (SELECT COALESCE(MAX(${this.qi('Sequence')}),0)+1 FROM ${this.qs(mj_core_schema(), 'ApplicationEntity')} WHERE ${this.qi('ApplicationID')} = '${appUUID}'), ${this.utcNow()}, ${this.utcNow()})`;
-                            await this.LogSQLAndExecute(pool, sSQLInsertApplicationEntity, `SQL generated to add new entity ${newEntityName} to application ID: '${appUUID}'`);
+                                       ('${appUUID}', '${newEntityID}', (SELECT COALESCE(MAX(${this.qi('Sequence')}),0)+1 FROM ${this.qs(MjCoreSchema(), 'ApplicationEntity')} WHERE ${this.qi('ApplicationID')} = '${appUUID}'), ${this.utcNow()}, ${this.utcNow()})`;
+                            await this.logSQLAndExecute(pool, sSQLInsertApplicationEntity, `SQL generated to add new entity ${newEntityName} to application ID: '${appUUID}'`);
                         }
                     }
                     else {
@@ -5268,7 +5490,7 @@ export class ManageMetadataBase {
                         const RoleID = md.Roles.find(r => r.Name.trim().toLowerCase() === p.RoleName.trim().toLowerCase())?.ID;
                         if (RoleID) {
                             const sSQLInsertPermission = this.buildEntityPermissionInsertSQL(newEntityID, RoleID, p.CanRead, p.CanCreate, p.CanUpdate, p.CanDelete);
-                            await this.LogSQLAndExecute(pool, sSQLInsertPermission, `SQL generated to add new permission for entity ${newEntityName} for role ${p.RoleName}`);
+                            await this.logSQLAndExecute(pool, sSQLInsertPermission, `SQL generated to add new permission for entity ${newEntityName} for role ${p.RoleName}`);
                         }
                         else
                             LogError(`   >>>> ERROR: Unable to find Role ID for role ${p.RoleName} to add permissions for new entity ${newEntityName}`);
@@ -5302,7 +5524,7 @@ export class ManageMetadataBase {
     async isSchemaNew(pool, schemaName) {
         // check to see if there are any entities in the db with this schema name
         // Quote the alias so PostgreSQL preserves PascalCase (unquoted aliases are lowercased in PG)
-        const sSQL = `SELECT COUNT(*) AS ${this.qi('Count')} FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE ${this.qi('SchemaName')} = '${schemaName}'`;
+        const sSQL = `SELECT COUNT(*) AS ${this.qi('Count')} FROM ${this.qs(MjCoreSchema(), 'Entity')} WHERE ${this.qi('SchemaName')} = '${schemaName}'`;
         const resultResult = await this.runQuery(pool, sSQL);
         const result = resultResult.recordset;
         // Use Number() because PG returns COUNT(*) as bigint, which the pg driver delivers as a string
@@ -5334,7 +5556,7 @@ export class ManageMetadataBase {
             // Guard the INSERT with an existence check so the emitted (and re-runnable) migration SQL is
             // idempotent. drop-schema clears an app's ApplicationEntity/EntityPermission/Entity rows but NOT
             // its Application row, so replaying this block would otherwise collide on the Application PK.
-            const appCheckQuery = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'Application')} WHERE ${this.qi('ID')} = '${appID}'`;
+            const appCheckQuery = `SELECT 1 FROM ${this.qs(MjCoreSchema(), 'Application')} WHERE ${this.qi('ID')} = '${appID}'`;
             // Schema-named bucket apps are plumbing (entity links, role grants, SchemaAutoAddNewEntities),
             // not products — hide them from new users. Application.DefaultForNewUser defaults to 1 in the
             // DB, so omitting the column here is what put raw '__mj_*'-named apps in every new user's
@@ -5343,10 +5565,10 @@ export class ManageMetadataBase {
             // statement in PG's `DO $$ ... $$` block, and the identifier auto-quoter skips dollar-quoted
             // blocks wholesale (they can legally contain arbitrary text), so nothing downstream will quote
             // these for us. Bare `ID` reaches PG folded to `id` and the INSERT fails on every run.
-            const appInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'Application')} (${this.qi('ID')}, ${this.qi('Name')}, ${this.qi('Description')}, ${this.qi('SchemaAutoAddNewEntities')}, ${this.qi('Path')}, ${this.qi('AutoUpdatePath')}, ${this.qi('DefaultForNewUser')})
+            const appInsert = `INSERT INTO ${this.qs(MjCoreSchema(), 'Application')} (${this.qi('ID')}, ${this.qi('Name')}, ${this.qi('Description')}, ${this.qi('SchemaAutoAddNewEntities')}, ${this.qi('Path')}, ${this.qi('AutoUpdatePath')}, ${this.qi('DefaultForNewUser')})
                        VALUES ('${appID}', '${appName}', 'Generated for schema', '${schemaName}', '${path}', ${this.dialect.BooleanLiteral(true)}, ${this.dialect.BooleanLiteral(false)})`;
             const sSQL = this.conditionalInsert(appCheckQuery, appInsert);
-            await this.LogSQLAndExecute(pool, sSQL, `SQL generated to create new application ${appName}`);
+            await this.logSQLAndExecute(pool, sSQL, `SQL generated to create new application ${appName}`);
             LogStatus(`Created new application ${appName} with Path: ${path}`);
             // Auto-assign default roles to the new application
             await this.addDefaultRolesForApplication(pool, appID, appName);
@@ -5374,12 +5596,12 @@ export class ManageMetadataBase {
                 // This covers BOTH re-running the block after drop-schema (which leaves ApplicationRole rows
                 // intact) AND the collision with the Integration role that manageMetadata recreates
                 // out-of-band — either path would otherwise violate UQ_ApplicationRole_App_Role.
-                const roleCheckQuery = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'ApplicationRole')} WHERE ${this.qi('ApplicationID')} = '${appId}' AND ${this.qi('RoleID')} = '${role.ID}'`;
-                const roleInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'ApplicationRole')}
+                const roleCheckQuery = `SELECT 1 FROM ${this.qs(MjCoreSchema(), 'ApplicationRole')} WHERE ${this.qi('ApplicationID')} = '${appId}' AND ${this.qi('RoleID')} = '${role.ID}'`;
+                const roleInsert = `INSERT INTO ${this.qs(MjCoreSchema(), 'ApplicationRole')}
                                  (${this.qi('ApplicationID')}, ${this.qi('RoleID')}, ${this.qi('CanAccess')}, ${this.qi('CanAdmin')}) VALUES
                                  ('${appId}', '${role.ID}', ${this.boolLit(roleDef.CanAccess)}, ${this.boolLit(roleDef.CanAdmin)})`;
                 const sSQLInsert = this.conditionalInsert(roleCheckQuery, roleInsert);
-                await this.LogSQLAndExecute(pool, sSQLInsert, `Adding role ${roleDef.RoleName} to application ${appName}`);
+                await this.logSQLAndExecute(pool, sSQLInsert, `Adding role ${roleDef.RoleName} to application ${appName}`);
             }
             else {
                 LogError(`Unable to find Role '${roleDef.RoleName}' for application ${appName}`);
@@ -5387,14 +5609,14 @@ export class ManageMetadataBase {
         }
     }
     async applicationExists(pool, applicationName) {
-        const sSQL = `SELECT ID FROM ${this.qs(mj_core_schema(), 'Application')} WHERE Name = '${applicationName}'`;
+        const sSQL = `SELECT ID FROM ${this.qs(MjCoreSchema(), 'Application')} WHERE Name = '${applicationName}'`;
         const resultResult = await this.runQuery(pool, sSQL);
         const result = resultResult.recordset;
         return result && result.length > 0 ? result[0].ID.length > 0 : false;
     }
     async getApplicationIDForSchema(pool, schemaName) {
         // get all the apps each time from DB as we might be adding, don't use Metadata here for that reason
-        const sSQL = `SELECT ID, Name, SchemaAutoAddNewEntities FROM ${this.qs(mj_core_schema(), 'vwApplications')}`;
+        const sSQL = `SELECT ID, Name, SchemaAutoAddNewEntities FROM ${this.qs(MjCoreSchema(), 'vwApplications')}`;
         const resultResult = await this.runQuery(pool, sSQL);
         const result = resultResult.recordset;
         if (!result || result.length === 0) {
@@ -5436,10 +5658,10 @@ export class ManageMetadataBase {
         if (apps && apps.length > 0) {
             if (configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
                 for (const appUUID of apps) {
-                    const sSQLInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'ApplicationEntity')}
+                    const sSQLInsert = `INSERT INTO ${this.qs(MjCoreSchema(), 'ApplicationEntity')}
                                     (${this.qi('ApplicationID')}, ${this.qi('EntityID')}, ${this.qi('Sequence')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')}) VALUES
-                                    ('${appUUID}', '${entityId}', (SELECT COALESCE(MAX(${this.qi('Sequence')}),0)+1 FROM ${this.qs(mj_core_schema(), 'ApplicationEntity')} WHERE ${this.qi('ApplicationID')} = '${appUUID}'), ${this.utcNow()}, ${this.utcNow()})`;
-                    await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to add entity ${entityName} to application ID: '${appUUID}'`);
+                                    ('${appUUID}', '${entityId}', (SELECT COALESCE(MAX(${this.qi('Sequence')}),0)+1 FROM ${this.qs(MjCoreSchema(), 'ApplicationEntity')} WHERE ${this.qi('ApplicationID')} = '${appUUID}'), ${this.utcNow()}, ${this.utcNow()})`;
+                    await this.logSQLAndExecute(pool, sSQLInsert, `SQL generated to add entity ${entityName} to application ID: '${appUUID}'`);
                 }
             }
         }
@@ -5465,7 +5687,7 @@ export class ManageMetadataBase {
      * valid on both SQL Server and PostgreSQL, so no provider branch is needed.
      */
     buildEntityPermissionInsertSQL(entityId, roleId, canRead, canCreate, canUpdate, canDelete) {
-        const table = this.qs(mj_core_schema(), 'EntityPermission');
+        const table = this.qs(MjCoreSchema(), 'EntityPermission');
         const entityLit = this.uuidLit(entityId);
         const roleLit = this.uuidLit(roleId);
         return `INSERT INTO ${table}
@@ -5490,7 +5712,7 @@ export class ManageMetadataBase {
             const RoleID = md.Roles.find(r => r.Name.trim().toLowerCase() === p.RoleName.trim().toLowerCase())?.ID;
             if (RoleID) {
                 const sSQLInsert = this.buildEntityPermissionInsertSQL(entityId, RoleID, p.CanRead, p.CanCreate, p.CanUpdate, p.CanDelete);
-                await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to add permission for entity ${entityName} for role ${p.RoleName}`);
+                await this.logSQLAndExecute(pool, sSQLInsert, `SQL generated to add permission for entity ${entityName} for role ${p.RoleName}`);
             }
             else {
                 LogError(`   >>>> ERROR: Unable to find Role ID for role ${p.RoleName} to add permissions for entity ${entityName}`);
@@ -5652,7 +5874,7 @@ export class ManageMetadataBase {
                 continue;
             }
             const sSQLInsert = this.buildEntityPermissionInsertSQL(entityId, roleId, true, false, false, false);
-            await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to add read permission for materialized entity ${entityName} for role ${p.RoleName}`);
+            await this.logSQLAndExecute(pool, sSQLInsert, `SQL generated to add read permission for materialized entity ${entityName} for role ${p.RoleName}`);
         }
     }
     /**
@@ -5662,8 +5884,8 @@ export class ManageMetadataBase {
      * human authors protection. Non-destructive (rows are kept, just flipped) so the grant can be restored.
      */
     async revokeMaterializedEntityReadAccess(pool, entityId, entityLabel, reason) {
-        const sql = `UPDATE ${this.qs(mj_core_schema(), 'EntityPermission')} SET ${this.qi('CanRead')}=${this.boolLit(false)} WHERE ${this.qi('EntityID')}='${entityId}' AND ${this.qi('CanRead')}=${this.boolLit(true)}`;
-        await this.LogSQLAndExecute(pool, sql, `Revoke read access on materialized entity "${entityLabel}" (${reason})`);
+        const sql = `UPDATE ${this.qs(MjCoreSchema(), 'EntityPermission')} SET ${this.qi('CanRead')}=${this.boolLit(false)} WHERE ${this.qi('EntityID')}='${entityId}' AND ${this.qi('CanRead')}=${this.boolLit(true)}`;
+        await this.logSQLAndExecute(pool, sql, `Revoke read access on materialized entity "${entityLabel}" (${reason})`);
     }
     /**
      * ROLE-RLS LAYER ONLY — true if any of the entity's role permissions carries a non-empty `ReadRLSFilterID`.
@@ -5734,7 +5956,7 @@ export class ManageMetadataBase {
             for (const table of ['APIKeyScope', 'APIApplicationScope']) {
                 if (!(await this.columnExistsInCoreSchema(pool, table, 'RowFilterID')))
                     continue;
-                const res = await this.runQuery(pool, `SELECT DISTINCT ${this.qi('ResourcePattern')} AS ResourcePattern FROM ${this.qs(mj_core_schema(), table)} WHERE ${this.qi('RowFilterID')} IS NOT NULL`);
+                const res = await this.runQuery(pool, `SELECT DISTINCT ${this.qi('ResourcePattern')} AS ResourcePattern FROM ${this.qs(MjCoreSchema(), table)} WHERE ${this.qi('RowFilterID')} IS NOT NULL`);
                 for (const row of res.recordset ?? []) {
                     const r = row;
                     const pattern = (r.ResourcePattern ?? r.resourcepattern) ?? '';
@@ -5767,7 +5989,7 @@ export class ManageMetadataBase {
         if (cached !== undefined)
             return cached;
         const sql = `SELECT COUNT(*) AS ColExists FROM INFORMATION_SCHEMA.COLUMNS ` +
-            `WHERE TABLE_SCHEMA = '${mj_core_schema()}' AND TABLE_NAME = '${table}' AND COLUMN_NAME = '${column}'`;
+            `WHERE TABLE_SCHEMA = '${MjCoreSchema()}' AND TABLE_NAME = '${table}' AND COLUMN_NAME = '${column}'`;
         const result = await this.runQuery(pool, sql);
         const row = (result.recordset?.[0] ?? {});
         const cnt = row.ColExists ?? row.colexists ?? 0;
@@ -5787,14 +6009,14 @@ export class ManageMetadataBase {
         if (sourceEntities.length === 0)
             return 0; // no sources to intersect against — the RLS/empty gate handles this
         const roleCanReadAllSources = (roleId) => sourceEntities.every((e) => e.Permissions.some((p) => UUIDsEqual(p.RoleID, roleId) && p.CanRead));
-        const grants = await this.runQuery(pool, `SELECT ${this.qi('RoleID')} FROM ${this.qs(mj_core_schema(), 'EntityPermission')} WHERE ${this.qi('EntityID')}='${entityId}' AND ${this.qi('CanRead')}=${this.boolLit(true)}`);
+        const grants = await this.runQuery(pool, `SELECT ${this.qi('RoleID')} FROM ${this.qs(MjCoreSchema(), 'EntityPermission')} WHERE ${this.qi('EntityID')}='${entityId}' AND ${this.qi('CanRead')}=${this.boolLit(true)}`);
         let revoked = 0;
         for (const g of grants.recordset) {
             const roleId = g.RoleID;
             if (!roleId)
                 continue;
             if (!roleCanReadAllSources(roleId)) {
-                await this.LogSQLAndExecute(pool, `UPDATE ${this.qs(mj_core_schema(), 'EntityPermission')} SET ${this.qi('CanRead')}=${this.boolLit(false)} WHERE ${this.qi('EntityID')}='${entityId}' AND ${this.qi('RoleID')}='${roleId}' AND ${this.qi('CanRead')}=${this.boolLit(true)}`, `Narrow read grant on materialized entity "${entityLabel}": role ${roleId} can no longer read every source (C2 intersection re-narrowed)`);
+                await this.logSQLAndExecute(pool, `UPDATE ${this.qs(MjCoreSchema(), 'EntityPermission')} SET ${this.qi('CanRead')}=${this.boolLit(false)} WHERE ${this.qi('EntityID')}='${entityId}' AND ${this.qi('RoleID')}='${roleId}' AND ${this.qi('CanRead')}=${this.boolLit(true)}`, `Narrow read grant on materialized entity "${entityLabel}": role ${roleId} can no longer read every source (C2 intersection re-narrowed)`);
                 revoked++;
             }
         }
@@ -5824,7 +6046,7 @@ export class ManageMetadataBase {
      *                    earlier in this run (which are not in metadata yet)
      * @returns the free name and the suffix used to reach it ('' when the name was already free)
      */
-    resolveUniqueEntityName(desiredName, schemaName, takenNames) {
+    ResolveUniqueEntityName(desiredName, schemaName, takenNames) {
         const taken = new Set([...takenNames, ...ManageMetadataBase.newEntityList].map(n => n.toLowerCase()));
         const isTaken = (candidate) => taken.has(candidate.toLowerCase());
         if (!isTaken(desiredName)) {
@@ -5843,13 +6065,17 @@ export class ManageMetadataBase {
         }
         return { name, suffix };
     }
+    /** @deprecated Use {@link ResolveUniqueEntityName}. */
+    resolveUniqueEntityName(desiredName, schemaName, takenNames) {
+        return this.ResolveUniqueEntityName(desiredName, schemaName, takenNames);
+    }
     createNewEntityInsertSQL(newEntityUUID, newEntityName, newEntity, newEntitySuffix, newEntityDisplayName) {
         const newEntityDefaults = configInfo.newEntityDefaults;
         const newEntityDescriptionEscaped = newEntity.EntityDescription ? `'${newEntity.EntityDescription.replace(/'/g, "''")}'` : null;
         const allowCaching = this.resolveAllowCachingForSchema(newEntity.SchemaName);
         const q = (name) => this.qi(name);
         const sSQLInsert = `
-      INSERT INTO ${this.qs(mj_core_schema(), 'Entity')} (
+      INSERT INTO ${this.qs(MjCoreSchema(), 'Entity')} (
          ${q('ID')},
          ${q('Name')},
          ${q('DisplayName')},
@@ -5910,7 +6136,7 @@ export class ManageMetadataBase {
         const match = overrides.find(entry => {
             let candidate = entry.SchemaName;
             if (candidate?.trim().toLowerCase() === '${mj_core_schema}') {
-                candidate = mj_core_schema();
+                candidate = MjCoreSchema();
             }
             return candidate.trim().toLowerCase() === schemaName.trim().toLowerCase();
         });
@@ -5971,7 +6197,7 @@ export class ManageMetadataBase {
                e.FullTextSearchEnabled,
                e.AutoUpdateFullTextSearch
             FROM
-               ${this.qs(mj_core_schema(), 'vwEntities')} e
+               ${this.qs(MjCoreSchema(), 'vwEntities')} e
             WHERE
                ${whereClause}
             ORDER BY
@@ -6020,7 +6246,7 @@ export class ManageMetadataBase {
                ef.AutoUpdateFullTextSearch,
                ef.${this.qi('Length')} as MaxLength
             FROM
-               ${this.qs(mj_core_schema(), 'vwEntityFields')} ef
+               ${this.qs(MjCoreSchema(), 'vwEntityFields')} ef
             WHERE
                ef.EntityID IN (${entityIds})
             ORDER BY
@@ -6038,7 +6264,7 @@ export class ManageMetadataBase {
                es.Name,
                es.Value
             FROM
-               ${this.qs(mj_core_schema(), 'EntitySetting')} es
+               ${this.qs(MjCoreSchema(), 'EntitySetting')} es
             WHERE
                es.EntityID IN (${entityIds})
                AND es.Name = 'FieldCategoryInfo'
@@ -6113,13 +6339,13 @@ export class ManageMetadataBase {
                 }
             }
             const pct = Math.round((processedCount / total) * 100);
-            updateSpinner(`Advanced generation: ${processedCount}/${total} entities (${pct}%)${errorCount > 0 ? ` — ${errorCount} error(s)` : ''}`);
+            UpdateSpinner(`Advanced generation: ${processedCount}/${total} entities (${pct}%)${errorCount > 0 ? ` — ${errorCount} error(s)` : ''}`);
             // Credential circuit tripped (e.g. keyless / mis-credentialed env) — stop issuing further
             // AI calls; the remaining entities would only produce doomed round-trips. One clear message
             // was already logged when the circuit opened.
             if (ag.AICircuitOpen) {
                 const skipped = total - processedCount;
-                updateSpinner(`Advanced generation: AI credential circuit open — skipping remaining ${skipped} entit${skipped === 1 ? 'y' : 'ies'} (check AI credentials).`);
+                UpdateSpinner(`Advanced generation: AI credential circuit open — skipping remaining ${skipped} entit${skipped === 1 ? 'y' : 'ies'} (check AI credentials).`);
                 break;
             }
         }
@@ -6290,7 +6516,7 @@ export class ManageMetadataBase {
         // Execute all updates in one batch
         if (sqlStatements.length > 0) {
             try {
-                await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set field properties for entity`, false);
+                await this.logSQLBatchAndExecute(pool, sqlStatements, `Set field properties for entity`, false);
             }
             catch (ex) {
                 logError('Error executing combined smart field SQL: ', ex);
@@ -6318,7 +6544,7 @@ export class ManageMetadataBase {
         const proposedSearchableCount = (result.searchableFields ?? []).length;
         const proposedAllowUserSearch = result.allowUserSearch === true;
         // 1. Shape cleanup (defensive — identifyFields() also runs this).
-        const cleaned = normalizeSmartFieldResultShape(result);
+        const cleaned = NormalizeSmartFieldResultShape(result);
         result.searchableFields = cleaned.searchableFields ?? [];
         result.searchPredicates = cleaned.searchPredicates ?? [];
         result.allowUserSearch = cleaned.allowUserSearch;
@@ -6339,14 +6565,14 @@ export class ManageMetadataBase {
                 droppedIneligibleCount += 1;
                 continue;
             }
-            if (isNarrativeFieldName(name) && !ftxEnabled) {
+            if (IsNarrativeFieldName(name) && !ftxEnabled) {
                 droppedNarrativeCount += 1;
                 continue;
             }
             eligible.push(name);
         }
         // 3. Per-entity cap.
-        const { accepted, dropped: droppedByCap } = applySearchableFieldsCap(eligible);
+        const { accepted, dropped: droppedByCap } = ApplySearchableFieldsCap(eligible);
         result.searchableFields = accepted;
         // 4. Predicate normalization. Build a fresh searchPredicates list keyed
         //    on the accepted fields. The LLM's proposed predicates are the input
@@ -6361,7 +6587,7 @@ export class ManageMetadataBase {
         const normalizedPredicates = [];
         let predicatesRewrittenCount = 0;
         for (const fieldName of accepted) {
-            const { predicate, rewritten } = normalizePredicate({
+            const { predicate, rewritten } = NormalizePredicate({
                 fieldName,
                 proposed: proposedByName.get(fieldName),
                 isInFullTextSearchFields: ftsFieldSet.has(fieldName),
@@ -6436,7 +6662,7 @@ export class ManageMetadataBase {
         // Set the winner when it isn't flagged yet (and auto-update is allowed).
         if (winner && winner.AutoUpdateIsNameField && winner.ID && !winner.IsNameField) {
             sqlStatements.push(`
-               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                SET IsNameField = ${this.boolLit(true)}
                WHERE ID = '${winner.ID}'
                AND AutoUpdateIsNameField = ${this.boolLit(true)}
@@ -6448,7 +6674,7 @@ export class ManageMetadataBase {
                 continue;
             }
             sqlStatements.push(`
-               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                SET IsNameField = ${this.boolLit(false)}
                WHERE ID = '${f.ID}'
                AND AutoUpdateIsNameField = ${this.boolLit(true)}
@@ -6597,7 +6823,7 @@ export class ManageMetadataBase {
         for (const field of defaultInViewFields) {
             if (!field.DefaultInView) {
                 sqlStatements.push(`
-               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                SET DefaultInView = ${this.boolLit(true)}
                WHERE ID = '${field.ID}'
                AND AutoUpdateDefaultInView = ${this.boolLit(true)}
@@ -6635,7 +6861,7 @@ export class ManageMetadataBase {
             }
             if (!field.IncludeInUserSearchAPI) {
                 sqlStatements.push(`
-               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                SET IncludeInUserSearchAPI = ${this.boolLit(true)}
                WHERE ID = '${field.ID}'
                AND AutoUpdateIncludeInUserSearchAPI = ${this.boolLit(true)}
@@ -6643,6 +6869,279 @@ export class ManageMetadataBase {
             }
         }
     }
+    /**
+     * Build the two deterministic search-flag hygiene statements.
+     *
+     * These exist because the LLM-driven smart-field pipeline cannot be relied on to run at all:
+     * `AdvancedGeneration.enabled` reads `enableAdvancedGeneration ?? false`, so on a default
+     * configuration none of `applySearchableFieldUpdates` / `applyEntitySearchConfig` ever
+     * executes — while every new entity is still INSERTed with `AllowUserSearchAPI = 1`
+     * (see `createNewEntityInsertSQL`). The result is an entity flagged searchable with nothing
+     * searchable on it, which is not a harmless default: `UserSearchString` against such an entity
+     * is a documented no-op (MJ#4581/#4582), so the data provider ignores the term and returns the
+     * UNFILTERED table. Global search then fans out to it on every keystroke and discards every row.
+     *
+     * Both statements are deterministic, need no model, and are safe to run on every pass:
+     *
+     *  1. **Seed** — an entity with NO searchable field gets its name-like columns flagged
+     *     (`NAME_LIKE_FIELD_NAMES`: Name, Title, FirstName, LastName, …). Those are what a person
+     *     types into a search box, so they are the one defensible default. Only fires when the
+     *     entity has nothing flagged at all, so it fills a gap rather than overriding anyone —
+     *     including the LLM, which has already run by this point when it is enabled.
+     *
+     *     Note this keys on the field's NAME, not on `IsNameField`. That flag looks like the
+     *     obvious source and is the wrong one: measured against a real database, seeding from it
+     *     would flag 54 fields of which 41 are VIRTUAL — the denormalized FK display columns
+     *     CodeGen puts on views (`Action`, `Agent`, `Artifact`). Those are computed by JOIN, so a
+     *     LIKE against them cannot seek any index, and flagging them would push 49 junction
+     *     entities into the global-search fan-out with unindexable predicates — the exact cost
+     *     `search-guardrails.ts` exists to prevent. It also picked up identifiers (`RecordID`,
+     *     `Token`, `ExternalSystemRecordID`) and a `Description`, which `isNarrativeFieldName`
+     *     rejects on the LLM path. And it would still not have fixed `MJ: Employees`, whose only
+     *     `IsNameField` is the virtual `FirstLast`; keying on the name reaches its real
+     *     `FirstName` / `LastName` columns, which is what the reported bug needed.
+     *  2. **Clear** — an entity STILL left with no searchable field has `AllowUserSearchAPI` turned
+     *     off, so it drops out of the search fan-out instead of contributing noise.
+     *
+     * Both honor the `AutoUpdate*` opt-outs, which is how an operator pins a hand-made decision —
+     * and is exactly how the curated entries in `metadata/entities/.entity-search-exclusions.json`
+     * protect themselves (they set `AutoUpdateAllowUserSearchAPI` to false alongside the flag).
+     *
+     * Full-text-search entities are exempt from both. An FTS entity is searchable through its
+     * INDEX: `createViewUserSearchSQL` takes the full-text branch before it ever reads
+     * `IncludeInUserSearchAPI`, so those flags are dead metadata there and the entity is a
+     * perfectly valid search target without them.
+     *
+     * Written as `UPDATE ... WHERE <key> IN (subquery)` rather than `UPDATE ... FROM ... JOIN`,
+     * which is T-SQL-only. The subquery form is ANSI and runs unchanged on both platforms.
+     */
+    buildSearchFlagHygieneSQL(excludeSchemas) {
+        const coreSchema = MjCoreSchema();
+        const entity = this.qs(coreSchema, 'Entity');
+        const entityField = this.qs(coreSchema, 'EntityField');
+        const yes = this.boolLit(true);
+        const no = this.boolLit(false);
+        // Same set the LLM path's isNameLikeFieldName() tests, lowered for a case-insensitive
+        // comparison that does not depend on the database collation.
+        const nameLikeList = NAME_LIKE_FIELD_NAMES.map(n => `'${n.toLowerCase()}'`).join(',');
+        // Every name in NAME_LIKE_FIELD_NAMES resolves to the same predicate, so one literal covers
+        // the whole seed. This MUST be set explicitly: `EntityField.UserSearchPredicateAPI` defaults
+        // to 'Contains' in the database, which is `LIKE '%term%'` — the unindexable scan the
+        // guardrails exist to prevent. Seeding the flag without the predicate would have made every
+        // seeded entity a full scan on every keystroke.
+        const seedPredicate = DefaultPredicateFor(NAME_LIKE_FIELD_NAMES[0]);
+        // The entity-shape guardrails the LLM path applies (`entityLevelEnableBlockedReason`).
+        // A log / audit / run-history table grows without bound and a detail / line-item child is
+        // reached through its parent; neither is a global-search target, whichever columns it has.
+        // Expressed as SQL rather than reusing the regex helpers because this runs in the database.
+        const shapeSuffixes = [
+            'Logs', 'Log', 'Runs', 'Run', 'Run History', 'Run Steps', 'Run Messages', 'Execution Logs',
+            'Details', 'Detail', 'Lines', 'Line', 'Items', 'Item', 'Steps', 'Step',
+            'Params', 'Param', 'Mappings', 'Mapping',
+        ];
+        // WORD boundaries, not raw suffixes. `LIKE '%Lines'` is a case-insensitive endsWith under
+        // the default collation, so it matched `Pipelines`, `Guidelines`, `Timelines`, `Airlines`,
+        // `Deadlines` and `Baselines`; `LIKE '%Logs'` matched `Catalogs`, `Dialogs` and `Blogs`;
+        // `LIKE '%Audit%'` matched `Auditors`. MJ's own metadata was not exempt — `MJ: ML Training
+        // Pipelines` was caught by `'%Lines'`. Those entities were then excluded from the seed and
+        // swept up by the clear (which carries no shape filter, deliberately — see below), so a
+        // guardrail meaning "do not bother seeding these" silently turned search OFF on them.
+        //
+        // Matching the final WORD keeps every intended shape — `Order Details`, `Audit Logs`,
+        // `MJ: AI Agent Runs` — while `Catalogs`, `Pipelines` and `Auditors` fall through to the
+        // seed as ordinary entities.
+        const nameEndsWithWord = (word) => `(e.${this.qi('Name')} = '${word}' OR e.${this.qi('Name')} LIKE '% ${word}')`;
+        const nameContainsWord = (word) => `(e.${this.qi('Name')} = '${word}'`
+            + ` OR e.${this.qi('Name')} LIKE '${word} %'`
+            + ` OR e.${this.qi('Name')} LIKE '% ${word}'`
+            + ` OR e.${this.qi('Name')} LIKE '% ${word} %')`;
+        const shapeClauses = shapeSuffixes
+            .map(sfx => nameEndsWithWord(sfx))
+            .concat([nameContainsWord('Audit'), nameContainsWord('Record Change')])
+            .join(' OR ');
+        const entityShapeFilter = `AND NOT (${shapeClauses})`;
+        // Schema names are configuration, not literals we control: double any apostrophe rather
+        // than interpolating it straight into the statement.
+        const schemaFilter = excludeSchemas.length > 0
+            ? `AND e.${this.qi('SchemaName')} NOT IN (${excludeSchemas.map(sc => `'${sc.replace(/'/g, "''")}'`).join(',')})`
+            : '';
+        // "This entity has nothing a user search can match." Mirrors
+        // `EntityInfo.HasSearchFields` and the runtime screen in EntitySearchProvider.
+        const noSearchableField = `NOT EXISTS (
+               SELECT 1 FROM ${entityField} f2
+               WHERE f2.${this.qi('EntityID')} = e.${this.qi('ID')}
+                 AND f2.${this.qi('IncludeInUserSearchAPI')} = ${yes}
+            )`;
+        // An FTS entity is searchable through its index, with no per-field flags involved.
+        const notFullText = `AND ${this.coalesce(`e.${this.qi('FullTextSearchEnabled')}`, no)} = ${no}`;
+        // The eligibility predicate here mirrors `isFieldEligibleForUserSearch` (and the runtime
+        // `isTextSearchableType` it was written against): not the primary key, a bounded text
+        // column. A name field that is neither is left alone rather than flagged uselessly.
+        // The candidate SELECTs are built once and used twice: once as the UPDATE's subquery, once
+        // as the probe `applySearchFlagHygiene` runs to decide whether to emit the UPDATE at all.
+        // Sharing the text is the point — a probe whose predicates could drift from the statement
+        // it guards would either suppress a needed write or emit a no-op one.
+        const seedCandidateSQL = `
+            SELECT ranked.${this.qi('ID')} FROM (
+               SELECT f.${this.qi('ID')},
+                      ROW_NUMBER() OVER (
+                         PARTITION BY f.${this.qi('EntityID')}
+                         ORDER BY f.${this.qi('Sequence')}, f.${this.qi('Name')}
+                      ) AS rn
+               FROM ${entityField} f
+               INNER JOIN ${entity} e ON e.${this.qi('ID')} = f.${this.qi('EntityID')}
+               WHERE LOWER(f.${this.qi('Name')}) IN (${nameLikeList})
+                 AND f.${this.qi('AutoUpdateIncludeInUserSearchAPI')} = ${yes}
+                 AND f.${this.qi('IncludeInUserSearchAPI')} = ${no}
+                 AND ${this.coalesce(`f.${this.qi('IsPrimaryKey')}`, no)} = ${no}
+                 AND ${this.coalesce(`f.${this.qi('IsVirtual')}`, no)} = ${no}
+                 AND LOWER(f.${this.qi('Type')}) IN ('nvarchar','varchar','char','nchar')
+                 AND ${this.coalesce(`f.${this.qi('Length')}`, '0')} <> -1
+                 AND e.${this.qi('VirtualEntity')} = ${no}
+                 AND e.${this.qi('AllowUserSearchAPI')} = ${yes}
+                 ${notFullText}
+                 ${entityShapeFilter}
+                 ${schemaFilter}
+                 AND ${noSearchableField}
+            ) ranked
+            WHERE ranked.rn <= ${MAX_SEARCHABLE_FIELDS_PER_ENTITY}`;
+        // The clear carries NO entity-shape filter, and that is deliberate rather than an
+        // oversight: a log / run / detail table is exactly what should drop out of the search
+        // fan-out, so the shapes the seed refuses to touch are meant to fall through to here.
+        //
+        // That composition is load-bearing and worth stating, because it means the shape list
+        // above does not merely withhold help — it DECIDES which entities get search turned off.
+        // A name wrongly matched there is not "left alone", it is disabled. Which is why the
+        // matching is word-boundary (see nameEndsWithWord) and why widening that list is a
+        // destructive change, not a conservative one.
+        const clearWhere = `e.${this.qi('AllowUserSearchAPI')} = ${yes}
+              AND e.${this.qi('AutoUpdateAllowUserSearchAPI')} = ${yes}
+              AND e.${this.qi('VirtualEntity')} = ${no}
+              ${notFullText}
+              ${schemaFilter}
+              AND ${noSearchableField}`;
+        const clearCandidateSQL = `
+            SELECT e.${this.qi('ID')}
+            FROM ${entity} e
+            WHERE ${clearWhere}`;
+        const seedSQL = `
+         UPDATE ${entityField}
+         SET ${this.qi('IncludeInUserSearchAPI')} = ${yes},
+             ${this.qi('UserSearchPredicateAPI')} = '${seedPredicate}'
+         WHERE ${this.qi('ID')} IN (${seedCandidateSQL}
+         )`;
+        const clearSQL = `
+         UPDATE ${entity}
+         SET ${this.qi('AllowUserSearchAPI')} = ${no}
+         WHERE ${this.qi('ID')} IN (${clearCandidateSQL}
+         )`;
+        // Derived-table alias is required by T-SQL and accepted by PostgreSQL, so one form serves
+        // both. COUNT(*) rather than EXISTS because the count also feeds the status line.
+        const seedProbeSQL = `SELECT COUNT(*) AS ${this.qi('Cnt')} FROM (${seedCandidateSQL}
+         ) probe`;
+        // The clear probe returns NAMES, not a count. Disabling search is the destructive half of
+        // this pass and it is effectively one-way: getting it back means flagging a field by hand
+        // AND pinning AutoUpdateAllowUserSearchAPI = 0, or the next run undoes the repair. An
+        // operator told "cleared 14 entities" has no way to learn which 14 without going to the
+        // database; naming them in the run output is the difference between an auditable change
+        // and a silent one. Shares `clearWhere` with the UPDATE so the two cannot disagree.
+        const clearProbeSQL = `
+         SELECT e.${this.qi('Name')} AS ${this.qi('Name')}
+         FROM ${entity} e
+         WHERE ${clearWhere}
+         ORDER BY e.${this.qi('Name')}`;
+        return { seedSQL, clearSQL, seedProbeSQL, clearProbeSQL };
+    }
+    /**
+     * Run the deterministic search-flag hygiene pass (see {@link buildSearchFlagHygieneSQL}).
+     *
+     * Runs OUTSIDE `applyAdvancedGeneration` and therefore regardless of whether advanced
+     * generation is enabled — which is the whole point, since it is off by default and an entity
+     * created under that default is exactly the one that needs this. Ordered after it so the
+     * model's choices, when it did run, are already in place and the seed only fills a real gap.
+     *
+     * COMPARE FIRST, then write — the T20 contract every-run config writers are held to (see
+     * `__tests__/idempotency/config-writers-compare-first.test.ts`). The two UPDATEs converge on
+     * their own, because the first pass makes `noSearchableField` false for every row it touches,
+     * so re-running them changes nothing. That is not sufficient: `LogSQLBatchAndExecute` writes
+     * whatever it is handed into the run's `CodeGen_Run_*.sql` capture whether or not a row moves,
+     * and the drift gate's warm-twice stage fails on ANY capture surviving a second run. Emitting
+     * unconditionally therefore reddened the gate on every PR while the data was perfectly
+     * idempotent — the data converged, the log did not. So each statement is emitted only when its
+     * own candidate probe finds work.
+     */
+    async applySearchFlagHygiene(pool, excludeSchemas) {
+        try {
+            const { seedSQL, clearSQL, seedProbeSQL, clearProbeSQL } = this.buildSearchFlagHygieneSQL(excludeSchemas);
+            // Order matters: seeding first means an entity whose name field was just flagged is no
+            // longer a candidate for having its AllowUserSearchAPI cleared. Reversed, the pass would
+            // disable search on an entity it was about to make searchable.
+            //
+            // 4th arg is `isRecurringScript`, NOT a throw flag — passing `false` here is the default
+            // and is spelled out only to make the intent explicit. Errors are caught below.
+            const seedCount = await this.searchFlagHygieneCandidateCount(pool, seedProbeSQL);
+            if (seedCount > 0) {
+                logStatus(`         Search-flag hygiene: seeding ${seedCount} name field(s)`);
+                await this.logSQLBatchAndExecute(pool, [seedSQL], 'Deterministic search-flag hygiene — seed name fields', false);
+            }
+            // Probed AFTER the seed has run, not alongside it. Seeding changes which entities still
+            // have nothing searchable, so a clear probe taken before it would count entities the seed
+            // was about to repair and emit a statement that then matched nothing — reintroducing the
+            // stray capture file this is here to avoid.
+            const clearNames = await this.searchFlagHygieneClearCandidates(pool, clearProbeSQL);
+            if (clearNames.length > 0) {
+                // NAME them. This is the destructive half and it is effectively one-way for an
+                // operator who does not know it happened.
+                const shown = clearNames.slice(0, 25).join(', ');
+                const more = clearNames.length > 25 ? `, ... and ${clearNames.length - 25} more` : '';
+                logStatus(`         Search-flag hygiene: turning AllowUserSearchAPI OFF on ${clearNames.length} entity(ies): ${shown}${more}`);
+                await this.logSQLBatchAndExecute(pool, [clearSQL], 'Deterministic search-flag hygiene — clear AllowUserSearchAPI', false);
+            }
+            return true;
+        }
+        catch (ex) {
+            // A probe that cannot run is NOT the same as "nothing to do", and must not be allowed to
+            // look like it. Before this pass compared first, a malformed statement was appended to
+            // the CodeGen_Run capture by SQLLogging BEFORE it was executed, so a broken pass left a
+            // surviving artifact and reddened the drift gate. Probing first removes that signal: the
+            // throw now happens before anything is written, so without a loud failure here the pass
+            // would silently do nothing while every gate stayed green — the exact silent no-op this
+            // whole change exists to eliminate, one level up in the fixer. The caller fails the run.
+            logError('Search-flag hygiene FAILED — search flags were NOT reconciled on this run', ex);
+            return false;
+        }
+    }
+    /**
+     * Row count for one of the search-flag hygiene probes (see {@link applySearchFlagHygiene}).
+     *
+     * Reads the first column of the first row positionally rather than by name, because the alias
+     * comes back cased differently across drivers. A probe that returns nothing is treated as no
+     * work, which is the safe direction: the statement is skipped rather than emitted blind.
+     */
+    async searchFlagHygieneCandidateCount(pool, probeSQL) {
+        const result = await this.runQuery(pool, probeSQL);
+        const row = result?.recordset?.[0];
+        if (!row) {
+            return 0;
+        }
+        const count = Number(Object.values(row)[0]);
+        return Number.isFinite(count) ? count : 0;
+    }
+    /**
+     * Names of the entities the clear would disable (see {@link applySearchFlagHygiene}).
+     *
+     * Valid only AFTER the seed has run, since seeding changes which entities still have nothing
+     * searchable. Names rather than a count because this is the destructive half: the run output
+     * is the only place an operator can see which entities lost search, and getting it back is
+     * manual.
+     */
+    async searchFlagHygieneClearCandidates(pool, probeSQL) {
+        const result = await this.runQuery(pool, probeSQL);
+        const rows = result?.recordset ?? [];
+        return rows
+            .map(r => String(Object.values(r)[0] ?? '').trim())
+            .filter(n => n.length > 0);
+    }
     /**
      * Returns true if the field is a sensible target for LIKE-based user search.
      * Mirrors the runtime guard in GenericDatabaseProvider.isTextSearchableType /
@@ -6684,7 +7183,7 @@ export class ManageMetadataBase {
             // Only update if the current value differs from the recommended predicate
             if (field.UserSearchPredicateAPI !== sp.predicate) {
                 sqlStatements.push(`
-               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                SET UserSearchPredicateAPI = '${sp.predicate}'
                WHERE ID = '${field.ID}'
                AND AutoUpdateUserSearchPredicate = ${this.boolLit(true)}
@@ -6715,7 +7214,7 @@ export class ManageMetadataBase {
             // the field-level guardrails, and refuses log/audit and detail/line-
             // item-shaped entities. Anything blocked here gets a one-line note in
             // the CodeGen run report so the team can audit proposals.
-            const blocked = entityLevelEnableBlockedReason({
+            const blocked = EntityLevelEnableBlockedReason({
                 entityName: entity.Name,
                 confidence: result.confidence,
                 acceptedSearchableFieldsCount: (result.searchableFields ?? []).length,
@@ -6731,7 +7230,7 @@ export class ManageMetadataBase {
         }
         if (newValue !== currentValue) {
             sqlStatements.push(`
-            UPDATE ${this.qs(mj_core_schema(), 'Entity')}
+            UPDATE ${this.qs(MjCoreSchema(), 'Entity')}
             SET AllowUserSearchAPI = ${this.boolLit(newValue)}
             WHERE ID = '${entity.ID}'
             AND AutoUpdateAllowUserSearchAPI = ${this.boolLit(true)}
@@ -6774,7 +7273,7 @@ export class ManageMetadataBase {
             const currentValue = !!entity.FullTextSearchEnabled;
             if (newValue !== currentValue) {
                 sqlStatements.push(`
-               UPDATE ${this.qs(mj_core_schema(), 'Entity')}
+               UPDATE ${this.qs(MjCoreSchema(), 'Entity')}
                SET FullTextSearchEnabled = ${this.boolLit(newValue)}
                WHERE ID = '${entity.ID}'
                AND AutoUpdateFullTextSearch = ${this.boolLit(true)}
@@ -6796,7 +7295,7 @@ export class ManageMetadataBase {
             }
             if (!field.FullTextSearchEnabled) {
                 sqlStatements.push(`
-               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               UPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
                SET FullTextSearchEnabled = ${this.boolLit(true)}
                WHERE ID = '${field.ID}'
                AND AutoUpdateFullTextSearch = ${this.boolLit(true)}
@@ -6841,7 +7340,7 @@ export class ManageMetadataBase {
      * Respects the AutoUpdateSupportsGeoCoding flag — if 0, the value is locked.
      */
     async detectAndSetGeoCodingSupport(pool, entity) {
-        const schema = mj_core_schema();
+        const schema = MjCoreSchema();
         // Check if the entity's AutoUpdateSupportsGeoCoding flag allows us to modify it
         const autoUpdateResult = await pool.query(`
          SELECT ${this.qi('AutoUpdateSupportsGeoCoding')}, ${this.qi('SupportsGeoCoding')}
@@ -6864,7 +7363,7 @@ export class ManageMetadataBase {
         const shouldSupportGeo = existingGeoCount > 0;
         const currentValue = row.SupportsGeoCoding ? true : false;
         if (shouldSupportGeo !== currentValue) {
-            await this.LogSQLAndExecute(pool, `
+            await this.logSQLAndExecute(pool, `
             UPDATE ${this.qs(schema, 'Entity')}
             SET ${this.qi('SupportsGeoCoding')} = ${this.boolLit(shouldSupportGeo)}
             WHERE ${this.qi('ID')} = '${entity.ID}' AND ${this.qi('AutoUpdateSupportsGeoCoding')} = ${this.boolLit(true)}
@@ -6938,14 +7437,14 @@ export class ManageMetadataBase {
                 continue;
             }
             const lockCtx = {
-                isNewEntity: ctx.isNewEntity,
-                isNewField: ManageMetadataBase.isFieldNew(entity.ID, field.Name),
-                descriptionReopened: ManageMetadataBase.isDisplayNameReopened(entity.ID, field.Name),
-                typeReopened: ManageMetadataBase.isTypeReopened(entity.ID, field.Name),
-                existingCategories,
+                IsNewEntity: ctx.isNewEntity,
+                IsNewField: ManageMetadataBase.isFieldNew(entity.ID, field.Name),
+                DescriptionReopened: ManageMetadataBase.isDisplayNameReopened(entity.ID, field.Name),
+                TypeReopened: ManageMetadataBase.isTypeReopened(entity.ID, field.Name),
+                ExistingCategories: existingCategories,
             };
-            const update = computeFieldMetadataUpdate(field, fieldCategory, lockCtx, this.validateExtendedType.bind(this), (val, fn) => this.sanitizeCodeType(val, fn ?? field.Name, entity.Name));
-            for (const skip of update.skipped) {
+            const update = ComputeFieldMetadataUpdate(field, fieldCategory, lockCtx, this.validateExtendedType.bind(this), (val, fn) => this.sanitizeCodeType(val, fn ?? field.Name, entity.Name));
+            for (const skip of update.Skipped) {
                 if (skip.reason === 'locked') {
                     reporter.counter('ai.fieldsLocked');
                 }
@@ -6972,7 +7471,7 @@ export class ManageMetadataBase {
                 setClauses.push(`CodeType = ${codeVal}`);
             }
             if (setClauses.length > 0) {
-                sqlStatements.push(`\n-- UPDATE Entity Field Category Info ${entity.Name}.${field.Name} \nUPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+                sqlStatements.push(`\n-- UPDATE Entity Field Category Info ${entity.Name}.${field.Name} \nUPDATE ${this.qs(MjCoreSchema(), 'EntityField')}
 SET 
    ${setClauses.join(',\n   ')}
 WHERE 
@@ -6981,7 +7480,7 @@ WHERE
         }
         if (sqlStatements.length > 0) {
             try {
-                await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set categories for ${sqlStatements.length} fields`, false);
+                await this.logSQLBatchAndExecute(pool, sqlStatements, `Set categories for ${sqlStatements.length} fields`, false);
             }
             catch (ex) {
                 logError('Error Applying Field Categories', ex);
@@ -6994,19 +7493,19 @@ WHERE
     async applyEntityIcon(pool, entityId, entityIcon, entityName) {
         if (!entityIcon || entityIcon.trim().length === 0)
             return;
-        const checkSQL = `SELECT Icon FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE ID = '${entityId}'`;
+        const checkSQL = `SELECT Icon FROM ${this.qs(MjCoreSchema(), 'Entity')} WHERE ID = '${entityId}'`;
         const entityCheck = await this.runQuery(pool, checkSQL);
         if (entityCheck.recordset.length > 0) {
             const currentIcon = entityCheck.recordset[0].Icon;
             if (!currentIcon || currentIcon.trim().length === 0) {
                 const escapedIcon = entityIcon.replace(/'/g, "''");
                 const updateSQL = `
-               UPDATE ${this.qs(mj_core_schema(), 'Entity')}
+               UPDATE ${this.qs(MjCoreSchema(), 'Entity')}
                SET ${this.qi('Icon')} = '${escapedIcon}', ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
                WHERE ${this.qi('ID')} = '${entityId}'
             `;
                 try {
-                    await this.LogSQLAndExecute(pool, updateSQL, `Set entity icon to ${entityIcon}`, false);
+                    await this.logSQLAndExecute(pool, updateSQL, `Set entity icon to ${entityIcon}`, false);
                     logStatus(`  Set entity icon: ${entityIcon}`);
                 }
                 catch (ex) {
@@ -7021,26 +7520,26 @@ WHERE
     async applyCategoryInfoSettings(pool, entityId, categoryInfo, _entityName) {
         if (!categoryInfo || Object.keys(categoryInfo).length === 0)
             return;
-        const canonicalInfo = canonicalJSONStringify(categoryInfo, 2);
+        const canonicalInfo = CanonicalJSONStringify(categoryInfo, 2);
         const infoJSON = canonicalInfo.replace(/'/g, "''");
         const ENTITY_SETTING_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
         // Upsert FieldCategoryInfo (new format)
-        const checkNewSQL = `SELECT ${this.qi('ID')}, ${this.qi('Value')} FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryInfo'`;
+        const checkNewSQL = `SELECT ${this.qi('ID')}, ${this.qi('Value')} FROM ${this.qs(MjCoreSchema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryInfo'`;
         const existingNew = await this.runQuery(pool, checkNewSQL);
         if (existingNew.recordset.length > 0) {
             let isMatch = false;
             try {
                 const rawVal = existingNew.recordset[0].Value;
                 const parsed = typeof rawVal === 'string' ? JSON.parse(rawVal) : rawVal;
-                isMatch = deepEqualJSON(parsed, categoryInfo);
+                isMatch = DeepEqualJSON(parsed, categoryInfo);
             }
             catch {
                 isMatch = false;
             }
             if (!isMatch) {
                 try {
-                    await this.LogSQLAndExecute(pool, `
-                  UPDATE ${this.qs(mj_core_schema(), 'EntitySetting')}
+                    await this.logSQLAndExecute(pool, `
+                  UPDATE ${this.qs(MjCoreSchema(), 'EntitySetting')}
                   SET ${this.qi('Value')} = '${infoJSON}', ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
                   WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryInfo'
                `, `Update FieldCategoryInfo setting for entity`, false);
@@ -7053,11 +7552,11 @@ WHERE
         else {
             const newId = uuidv5(`${entityId}|FieldCategoryInfo`, ENTITY_SETTING_NAMESPACE);
             try {
-                const checkQuery = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryInfo'`;
-                const insertSQL = `INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('Name')}, ${this.qi('Value')}, ${this.qi(EntityInfo.CreatedAtFieldName)}, ${this.qi(EntityInfo.UpdatedAtFieldName)})
+                const checkQuery = `SELECT 1 FROM ${this.qs(MjCoreSchema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryInfo'`;
+                const insertSQL = `INSERT INTO ${this.qs(MjCoreSchema(), 'EntitySetting')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('Name')}, ${this.qi('Value')}, ${this.qi(EntityInfo.CreatedAtFieldName)}, ${this.qi(EntityInfo.UpdatedAtFieldName)})
                VALUES ('${newId}', '${entityId}', 'FieldCategoryInfo', '${infoJSON}', ${this.utcNow()}, ${this.utcNow()})`;
                 const sSQL = this.conditionalInsert(checkQuery, insertSQL);
-                await this.LogSQLAndExecute(pool, sSQL, `Insert FieldCategoryInfo setting for entity`, false);
+                await this.logSQLAndExecute(pool, sSQL, `Insert FieldCategoryInfo setting for entity`, false);
             }
             catch (ex) {
                 logError('Error Applying Category Info Settings: Part 2', ex);
@@ -7070,24 +7569,24 @@ WHERE
                 iconsOnly[category] = info.icon;
             }
         }
-        const canonicalIcons = canonicalJSONStringify(iconsOnly, 2);
+        const canonicalIcons = CanonicalJSONStringify(iconsOnly, 2);
         const iconsJSON = canonicalIcons.replace(/'/g, "''");
-        const checkLegacySQL = `SELECT ${this.qi('ID')}, ${this.qi('Value')} FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryIcons'`;
+        const checkLegacySQL = `SELECT ${this.qi('ID')}, ${this.qi('Value')} FROM ${this.qs(MjCoreSchema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryIcons'`;
         const existingLegacy = await this.runQuery(pool, checkLegacySQL);
         if (existingLegacy.recordset.length > 0) {
             let isMatch = false;
             try {
                 const rawVal = existingLegacy.recordset[0].Value;
                 const parsed = typeof rawVal === 'string' ? JSON.parse(rawVal) : rawVal;
-                isMatch = deepEqualJSON(parsed, iconsOnly);
+                isMatch = DeepEqualJSON(parsed, iconsOnly);
             }
             catch {
                 isMatch = false;
             }
             if (!isMatch) {
                 try {
-                    await this.LogSQLAndExecute(pool, `
-                  UPDATE ${this.qs(mj_core_schema(), 'EntitySetting')}
+                    await this.logSQLAndExecute(pool, `
+                  UPDATE ${this.qs(MjCoreSchema(), 'EntitySetting')}
                   SET ${this.qi('Value')} = '${iconsJSON}', ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
                   WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryIcons'
                `, `Update FieldCategoryIcons setting (legacy)`, false);
@@ -7100,11 +7599,11 @@ WHERE
         else {
             const newId = uuidv5(`${entityId}|FieldCategoryIcons`, ENTITY_SETTING_NAMESPACE);
             try {
-                const checkQuery = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryIcons'`;
-                const insertSQL = `INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('Name')}, ${this.qi('Value')}, ${this.qi(EntityInfo.CreatedAtFieldName)}, ${this.qi(EntityInfo.UpdatedAtFieldName)})
+                const checkQuery = `SELECT 1 FROM ${this.qs(MjCoreSchema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryIcons'`;
+                const insertSQL = `INSERT INTO ${this.qs(MjCoreSchema(), 'EntitySetting')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('Name')}, ${this.qi('Value')}, ${this.qi(EntityInfo.CreatedAtFieldName)}, ${this.qi(EntityInfo.UpdatedAtFieldName)})
                VALUES ('${newId}', '${entityId}', 'FieldCategoryIcons', '${iconsJSON}', ${this.utcNow()}, ${this.utcNow()})`;
                 const sSQL = this.conditionalInsert(checkQuery, insertSQL);
-                await this.LogSQLAndExecute(pool, sSQL, `Insert FieldCategoryIcons setting (legacy)`, false);
+                await this.logSQLAndExecute(pool, sSQL, `Insert FieldCategoryIcons setting (legacy)`, false);
             }
             catch (ex) {
                 logError('Error Applying Category Info Settings: Part 4', ex);
@@ -7117,12 +7616,12 @@ WHERE
      */
     async applyEntityImportance(pool, entityId, importance, entityName) {
         const updateSQL = `
-         UPDATE ${this.qs(mj_core_schema(), 'ApplicationEntity')}
+         UPDATE ${this.qs(MjCoreSchema(), 'ApplicationEntity')}
          SET ${this.qi('DefaultForNewUser')} = ${this.boolLit(importance.defaultForNewUser)}, ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
          WHERE ${this.qi('EntityID')} = '${entityId}'
       `;
         try {
-            await this.LogSQLAndExecute(pool, updateSQL, `Set DefaultForNewUser=${importance.defaultForNewUser} for NEW entity (category: ${importance.entityCategory}, confidence: ${importance.confidence})`, false);
+            await this.logSQLAndExecute(pool, updateSQL, `Set DefaultForNewUser=${importance.defaultForNewUser} for NEW entity (category: ${importance.entityCategory}, confidence: ${importance.confidence})`, false);
             logStatus(`  Entity importance (NEW Entity): ${importance.entityCategory} (defaultForNewUser: ${importance.defaultForNewUser}, confidence: ${importance.confidence})`);
             logStatus(`    Reasoning: ${importance.reasoning}`);
         }
@@ -7140,8 +7639,8 @@ WHERE
      * @param isRecurringScript - if set to true tells the logger that the provided SQL represents a recurring script meaning it is something that is executed, generally, for all CodeGen runs. In these cases, the Config settings can result in omitting these recurring scripts from being logged because the configuration environment may have those recurring scripts already set to run after all run-specific migrations get run.
      * @returns - The result of the query execution.
      */
-    async LogSQLAndExecute(pool, query, description, isRecurringScript = false, includeBatchSeparator = false, batchSeparator = 'GO') {
-        return await SQLLogging.LogSQLAndExecute(pool, this.qsql(query), description, isRecurringScript, includeBatchSeparator, batchSeparator);
+    async logSQLAndExecute(pool, query, description, isRecurringScript = false, includeBatchSeparator = false, batchSeparator = 'GO', requiresOwnBatch = false) {
+        return await SQLLogging.LogSQLAndExecute(pool, this.qsql(query), description, isRecurringScript, includeBatchSeparator, batchSeparator, requiresOwnBatch);
     }
     /**
      * Logs and executes a sequence of SQL statements as a single batch.
@@ -7159,17 +7658,17 @@ WHERE
      * Empty / whitespace-only statements are filtered out. Returns
      * `undefined` (no execution) when nothing remains.
      */
-    async LogSQLBatchAndExecute(pool, statements, description, isRecurringScript = false, includeBatchSeparator = false, batchSeparator = 'GO') {
+    async logSQLBatchAndExecute(pool, statements, description, isRecurringScript = false, includeBatchSeparator = false, batchSeparator = 'GO') {
         const terminated = [];
         for (const s of statements) {
-            const trimmed = (s ?? '').replace(/[\s;]+$/g, '');
+            const trimmed = TrimTrailingStatementTerminators(s ?? '');
             if (trimmed.length === 0)
                 continue;
             terminated.push(`${trimmed};`);
         }
         if (terminated.length === 0)
             return undefined;
-        return await this.LogSQLAndExecute(pool, terminated.join('\n'), description, isRecurringScript, includeBatchSeparator, batchSeparator);
+        return await this.logSQLAndExecute(pool, terminated.join('\n'), description, isRecurringScript, includeBatchSeparator, batchSeparator);
     }
 }
 //# sourceMappingURL=manage-metadata.js.map