udp-stencil-component-library 26.8.0 → 26.9.0-beta.0

package/dist/cjs/advanced-search_12.cjs.entry.js

@@ -2,7 +2,7 @@
 
 var index = require('./index-CZB9dMeB.js');
 var conversionFunctions = require('./conversionFunctions-B_9y17KE.js');
-var catalogStore = require('./catalog-store-CrTx8FL-.js');
+var catalogStore = require('./catalog-store-B_YMkXRh.js');
 var Close24 = require('@carbon/icons/es/close/24');
 var uuid = require('uuid');
 var Save16 = require('@carbon/icons/es/save/16');
@@ -14,8 +14,8 @@ var Star16 = require('@carbon/icons/es/star/16');
 var AdvancedQuery16 = require('@carbon/icons/es/ibm-watson--discovery/16');
 var DataEnrichment16 = require('@carbon/icons/es/idea/16');
 var Renew16 = require('@carbon/icons/es/renew/16');
-require('./apiUtils-DMOOqk3y.js');
-require('deep-equal');
+require('./apiUtils-0pkNuvqf.js');
+require('lodash-es/isEqual');
 require('./makeApiCall-CFfg9gI0.js');
 require('axios');
 require('./configService-N6ke1_s4.js');

package/dist/cjs/ag-grid-base_65.cjs.entry.js

@@ -2,13 +2,13 @@
 
 var index = require('./index-CZB9dMeB.js');
 var agGridEnterpriseV33 = require('ag-grid-enterprise-v33');
-var apiUtils = require('./apiUtils-DMOOqk3y.js');
-var lookupHelper = require('./lookupHelper-DPnaYUT4.js');
+var apiUtils = require('./apiUtils-0pkNuvqf.js');
+var lookupHelper = require('./lookupHelper-ClpMWN_g.js');
 var tenantUtils = require('./tenantUtils-BCKSE0vq.js');
 var searchObject = require('./searchObject-mbqgqdRh.js');
 var searchObjectHelper = require('./searchObjectHelper-DYpPEIzz.js');
 var statusRenderer = require('./status-renderer-9CQ-hhq8.js');
-var configureUdpColumnMods = require('./configureUdpColumnMods-CongQl55.js');
+var configureUdpColumnMods = require('./configureUdpColumnMods-BT7UbQPh.js');
 var lodashEs = require('lodash-es');
 var makeApiCall = require('./makeApiCall-CFfg9gI0.js');
 var configService = require('./configService-N6ke1_s4.js');
@@ -58,7 +58,7 @@ require('@fluentui/web-components/textarea.js');
 require('@fluentui/web-components/tooltip.js');
 require('@fluentui/web-components/tree.js');
 require('@fluentui/web-components/tree-item.js');
-require('deep-equal');
+require('lodash-es/isEqual');
 require('axios');
 require('./iconMapping-D932h4o2.js');
 require('@carbon/icons/es/add/16');

package/dist/cjs/ambient-template-grid.cjs.entry.js

@@ -2,11 +2,11 @@
 
 var index = require('./index-CZB9dMeB.js');
 var immer = require('immer');
-var catalogStore = require('./catalog-store-CrTx8FL-.js');
+var catalogStore = require('./catalog-store-B_YMkXRh.js');
 var ChooseItem16 = require('@carbon/icons/es/choose-item/16');
 var Star16 = require('@carbon/icons/es/star/16');
 var List16 = require('@carbon/icons/es/list/16');
-var apiUtils = require('./apiUtils-DMOOqk3y.js');
+var apiUtils = require('./apiUtils-0pkNuvqf.js');
 var transformSearchData = require('./transformSearchData-B4bk4Aik.js');
 var conversionFunctions = require('./conversionFunctions-B_9y17KE.js');
 var localforage = require('localforage');
@@ -16,7 +16,7 @@ var fastTypescriptMemoize = require('fast-typescript-memoize');
 var lodashEs = require('lodash-es');
 var uuid = require('uuid');
 var tenantUtils = require('./tenantUtils-BCKSE0vq.js');
-require('deep-equal');
+require('lodash-es/isEqual');
 require('./makeApiCall-CFfg9gI0.js');
 require('axios');
 require('./configService-N6ke1_s4.js');

package/dist/cjs/api-method-instance-grid.cjs.entry.js

@@ -4,14 +4,14 @@ var index = require('./index-CZB9dMeB.js');
 var makeApiCall = require('./makeApiCall-CFfg9gI0.js');
 var searchObjectHelper = require('./searchObjectHelper-DYpPEIzz.js');
 var lodashEs = require('lodash-es');
-var apiMethodInstance = require('./apiMethodInstance-Dl1OvqO3.js');
+var apiMethodInstance = require('./apiMethodInstance-D65NIw8S.js');
 var configService = require('./configService-N6ke1_s4.js');
 require('axios');
 require('./searchObject-mbqgqdRh.js');
-require('./configureUdpColumnMods-CongQl55.js');
-require('./lookupHelper-DPnaYUT4.js');
-require('./apiUtils-DMOOqk3y.js');
-require('deep-equal');
+require('./configureUdpColumnMods-BT7UbQPh.js');
+require('./lookupHelper-ClpMWN_g.js');
+require('./apiUtils-0pkNuvqf.js');
+require('lodash-es/isEqual');
 require('./tenantUtils-BCKSE0vq.js');
 
 const ApiMethodInstanceGrid = class {

package/dist/cjs/{apiMethodInstance-Dl1OvqO3.js → apiMethodInstance-D65NIw8S.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var configureUdpColumnMods = require('./configureUdpColumnMods-CongQl55.js');
+var configureUdpColumnMods = require('./configureUdpColumnMods-BT7UbQPh.js');
 
 function mapDotNetTypeToAgGridType(type) {
     const normalized = type.replace(/\?$/, '').trim().toLowerCase();

package/dist/cjs/{apiUtils-DMOOqk3y.js → apiUtils-0pkNuvqf.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var deepEqual = require('deep-equal');
+var isEqual = require('lodash-es/isEqual');
 var makeApiCall = require('./makeApiCall-CFfg9gI0.js');
 var configService = require('./configService-N6ke1_s4.js');
 var index = require('./index-CZB9dMeB.js');
@@ -8,7 +8,7 @@ var tenantUtils = require('./tenantUtils-BCKSE0vq.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var deepEqual__default = /*#__PURE__*/_interopDefault(deepEqual);
+var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
 
 const appendToMap = (map, propName, value) => {
     const items = map.get(propName);
@@ -238,15 +238,15 @@ const getBaseUrls = async () => {
     return baseUrls;
 };
 
-const { state, onChange } = createStore({
+const { state: state$1, onChange } = createStore({
     lookupsDataMap: null,
 });
 function setLookupsDataMap(lookupsDataMap, replace = false) {
     if (replace) {
-        state.lookupsDataMap = lookupsDataMap;
+        state$1.lookupsDataMap = lookupsDataMap;
     }
     else {
-        state.lookupsDataMap = Object.assign(Object.assign({}, state.lookupsDataMap), lookupsDataMap);
+        state$1.lookupsDataMap = Object.assign(Object.assign({}, state$1.lookupsDataMap), lookupsDataMap);
     }
 }
 
@@ -254,9 +254,342 @@ var lookupsStore = /*#__PURE__*/Object.freeze({
     __proto__: null,
     onChange: onChange,
     setLookupsDataMap: setLookupsDataMap,
-    state: state
+    state: state$1
 });
 
+var _a, _b, _c, _d, _e, _f, _g;
+/**
+ * BasicOperation type ids of the promoted base operations executable
+ * product-side — every operation the emitted UdpQuery runtime dispatches
+ * (UNT-6403): reads (Get=1, GetAll=5, Search=6, GetConfig=7, GetFull=8,
+ * Describe=9, GetData=10, Export=16, GetFileResult=18), writes (Create=2,
+ * Update=3, Delete=4, Import=15), and the virtual row operations
+ * (VirtualGet..VirtualDelete=11-14). BulkCreate=17 is dispatcher-ready but
+ * excluded until PromotedApiMethodView gains a BulkCreate slot the catalog can
+ * expose. The dispatcher independently rejects anything it does not support
+ * (501), so this list is a routing optimization, not a security boundary.
+ */
+const DIRECT_ELIGIBLE_BASE_OPERATION_TYPE_IDS = [
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    '10',
+    '11',
+    '12',
+    '13',
+    '14',
+    '15',
+    '16',
+    '18',
+];
+// The stencil dist ships several bundle flavors, and a page routinely loads two of
+// them at once: utility imports through the package root resolve to dist/esm, while
+// the React wrappers load the components (and everything they bundle, including this
+// module) from dist/components. Module-scoped state therefore SPLITS — the enterprise
+// library's writes land in the esm copy while the grid datasource reads the
+// components copy. Backing the state with a namespaced global keeps every compiled
+// copy reading and writing the same object. Reads are imperative (resolveExecutionTarget
+// at request time), so no store reactivity is needed.
+const EXECUTION_STATE_GLOBAL_KEY = '__udpQueryExecutionState__';
+const globalScope = globalThis;
+const state = ((_a = globalScope[EXECUTION_STATE_GLOBAL_KEY]) !== null && _a !== void 0 ? _a : (globalScope[EXECUTION_STATE_GLOBAL_KEY] = {
+    queryExecution: null,
+    directEligibleApiMethodIds: [],
+    integrationOnlyIds: [],
+    integrationFallbackStatuses: {},
+    descriptorKnown: false,
+    eligibilityKnown: false,
+    descriptorResolving: false,
+    descriptorWaiters: [],
+}));
+// A copy of this module compiled into an older bundle may have created the
+// global without newer fields; heal the shape instead of trusting it.
+(_b = state.integrationOnlyIds) !== null && _b !== void 0 ? _b : (state.integrationOnlyIds = []);
+(_c = state.integrationFallbackStatuses) !== null && _c !== void 0 ? _c : (state.integrationFallbackStatuses = {});
+(_d = state.descriptorKnown) !== null && _d !== void 0 ? _d : (state.descriptorKnown = false);
+(_e = state.eligibilityKnown) !== null && _e !== void 0 ? _e : (state.eligibilityKnown = false);
+(_f = state.descriptorResolving) !== null && _f !== void 0 ? _f : (state.descriptorResolving = false);
+(_g = state.descriptorWaiters) !== null && _g !== void 0 ? _g : (state.descriptorWaiters = []);
+/**
+ * Strips trailing '/' characters. A loop rather than `/\/+$/`, which
+ * backtracks quadratically on inputs with many embedded slashes.
+ */
+const trimTrailingSlashes = (url) => {
+    let end = url.length;
+    while (end > 0 && url[end - 1] === '/')
+        end--;
+    return url.slice(0, end);
+};
+/**
+ * Ad hoc UdpQuery execution endpoint emitted into every generated product app —
+ * contract with the code generator's UdpQueryControllerGenerator.
+ */
+const buildDirectAdhocRequestUrl = (productBaseUrl, apiMethodId) => `${trimTrailingSlashes(productBaseUrl)}/api/v1/UdpQuery/adhoc/${apiMethodId}`;
+/**
+ * With-parameters UdpQuery execution endpoint emitted into every generated
+ * product app — the direct counterpart of Integration's
+ * `apimethod/executeQueryWithParameters/{apiMethodId}`. Same request body
+ * contract (a flat name→value map plus an optional `requestBody` entry).
+ */
+const buildDirectExecuteWithParametersUrl = (productBaseUrl, apiMethodId) => `${trimTrailingSlashes(productBaseUrl)}/api/v1/UdpQuery/${apiMethodId}/executeWithParameters`;
+/**
+ * Instance-mode UdpQuery execution endpoint (saved query instances, the only
+ * mode applying alias/lookup result mapping). Per-instance operation
+ * eligibility cannot be derived client-side — the promoted catalog keys by
+ * apiMethodId, not instance id — so instance callers route direct on the
+ * descriptor alone and rely on the dispatcher's 501 plus the fallback contract.
+ */
+const buildDirectExecuteInstanceUrl = (productBaseUrl, apiMethodInstanceId) => `${trimTrailingSlashes(productBaseUrl)}/api/v1/UdpQuery/${apiMethodInstanceId}/execute`;
+/**
+ * Response header the emitted UdpQuery controller stamps on every response it
+ * produces, success and error alike. Its absence on a 404 means the endpoint
+ * itself is missing (a build without the runtime); the product's CORS policy
+ * must expose it (Access-Control-Expose-Headers) for cross-origin callers.
+ */
+const UDP_QUERY_RUNTIME_MARKER_HEADER = 'x-udpquery-runtime';
+/**
+ * The migration-window fallback contract for a failed DIRECT execution: retry
+ * via Integration only on 501 (the runtime's "not supported / not configured
+ * here — execute on Integration" signal, which also covers product builds
+ * whose runtime predates an operation), on a 404 WITHOUT the runtime marker
+ * header (endpoint absent), and — for reads only — on 503. Never on
+ * marker-carrying 404s or any other status — a real query error must surface,
+ * not silently re-execute on the other path and mask a broken direct route.
+ */
+const shouldFallBackToIntegration = (status, hasRuntimeMarker, options = {}) => status === 501 || (status === 503 && !options.mayWrite) || (status === 404 && !hasRuntimeMarker);
+/**
+ * The one implementation of the migration-window fallback, shared by every
+ * executor seam (stencil apiUtils, the React library's methodUtils): run the
+ * direct call, and on a {@link shouldFallBackToIntegration} failure retry via
+ * Integration; rethrow everything else. 501 and markerless 404 describe the
+ * deployed build, so the id goes integration-only for the rest of the page
+ * load; 503 is transient, so only this call falls back.
+ */
+const directCallWithIntegrationFallback = async (directCall, integrationCall, id, options = {}) => {
+    try {
+        const result = await directCall();
+        clearIntegrationFallbackStatus(id);
+        return result;
+    }
+    catch (error) {
+        const response = error === null || error === void 0 ? void 0 : error.response;
+        const status = response === null || response === void 0 ? void 0 : response.status;
+        const headers = response === null || response === void 0 ? void 0 : response.headers;
+        const hasMarker = !!(headers &&
+            (typeof headers.get === 'function'
+                ? headers.get(UDP_QUERY_RUNTIME_MARKER_HEADER)
+                : headers[UDP_QUERY_RUNTIME_MARKER_HEADER]));
+        if (shouldFallBackToIntegration(status, hasMarker, options)) {
+            console.warn(`Direct UdpQuery execution answered ${status}; falling back to Integration`, error);
+            if (status === 503) {
+                recordIntegrationFallbackStatus(id, status);
+            }
+            else {
+                // Skip the wasted direct attempt for this id for the rest of the page load.
+                markIntegrationOnly(id, status);
+            }
+            return integrationCall();
+        }
+        throw error;
+    }
+};
+/**
+ * Records that a direct execution for this id (apiMethodId or instance id)
+ * answered the fallback signal, so subsequent executions this page load skip
+ * the wasted direct attempt and go straight to Integration.
+ */
+function markIntegrationOnly(id, status) {
+    if (id && !state.integrationOnlyIds.includes(id)) {
+        state.integrationOnlyIds = [...state.integrationOnlyIds, id];
+        if (typeof status === 'number') {
+            state.integrationFallbackStatuses = Object.assign(Object.assign({}, state.integrationFallbackStatuses), { [id]: status });
+        }
+    }
+}
+function recordIntegrationFallbackStatus(id, status) {
+    if (id) {
+        state.integrationFallbackStatuses = Object.assign(Object.assign({}, state.integrationFallbackStatuses), { [id]: status });
+    }
+}
+function clearIntegrationFallbackStatus(id) {
+    if (id && id in state.integrationFallbackStatuses) {
+        const rest = Object.assign({}, state.integrationFallbackStatuses);
+        delete rest[id];
+        state.integrationFallbackStatuses = rest;
+    }
+}
+/**
+ * The HTTP status this id's latest direct attempt fell back on (501, 503 or a
+ * markerless 404), or undefined when it has not fallen back or its latest
+ * direct attempt succeeded. 501/404 also make the id integration-only for the
+ * page load, so they stick; a 503 clears on the next direct success.
+ */
+function getIntegrationFallbackStatus(id) {
+    return id ? state.integrationFallbackStatuses[id] : undefined;
+}
+function isIntegrationOnly(id) {
+    return !!id && state.integrationOnlyIds.includes(id);
+}
+/**
+ * Announces an in-flight descriptor fetch, arming the boot barrier: from this
+ * call until the routing answer settles (see isExecutionRoutingSettled),
+ * whenExecutionRoutingSettled parks executors instead of letting their first
+ * query silently fail open to Integration. Idempotent; called by the provider
+ * that owns the tenant x product descriptor fetch as soon as it mounts.
+ * Whoever calls this MUST guarantee a descriptor write follows (success or
+ * failure), and — when that write says direct — a bulk eligibility write too,
+ * or parked executors never run.
+ */
+function markQueryExecutionResolving() {
+    if (!isExecutionRoutingSettled()) {
+        state.descriptorResolving = true;
+    }
+}
+/**
+ * The routing question is settled once the descriptor is known and, when it
+ * says direct, the bulk eligibility registration has landed as well — before
+ * that, every per-id eligibility check would miss and route Integration.
+ * An integration (or absent) descriptor settles alone: eligibility is
+ * irrelevant on that path.
+ */
+function isExecutionRoutingSettled() {
+    var _a;
+    return state.descriptorKnown && (((_a = state.queryExecution) === null || _a === void 0 ? void 0 : _a.mode) !== 'direct' || state.eligibilityKnown);
+}
+function releaseBarrierIfSettled() {
+    if (isExecutionRoutingSettled()) {
+        releaseQueryExecutionResolving();
+    }
+}
+/**
+ * How long a parked executor waits for the routing answer before failing open
+ * to Integration.
+ */
+const EXECUTION_ROUTING_SETTLE_TIMEOUT_MS = 10000;
+/**
+ * Disarms the boot barrier and releases every parked executor onto whatever
+ * routing is known (Integration until a descriptor lands). For a provider that
+ * unmounts mid-fetch, and the barrier's own timeout. A descriptor or
+ * eligibility write arriving later still takes effect for subsequent queries.
+ */
+function releaseQueryExecutionResolving() {
+    state.descriptorResolving = false;
+    const waiters = state.descriptorWaiters;
+    state.descriptorWaiters = [];
+    waiters.forEach((release) => release());
+}
+/**
+ * Starts routing over for a new scope (tenant switch): forgets the descriptor
+ * and every per-id Integration fallback, and re-arms the boot barrier so
+ * executors park until the new scope's descriptor lands instead of running on
+ * the previous one's. The eligible set is kept — it is keyed by the api
+ * catalog, and the provider replaces it whenever the catalog changes. Same
+ * contract as markQueryExecutionResolving: a descriptor write MUST follow.
+ */
+function resetQueryExecutionRouting() {
+    state.queryExecution = null;
+    state.descriptorKnown = false;
+    state.integrationOnlyIds = [];
+    state.integrationFallbackStatuses = {};
+    state.descriptorResolving = true;
+}
+/**
+ * The boot barrier: resolves once the routing question is settled for this
+ * page load. Immediate when it already is — or when no provider has announced
+ * a descriptor fetch, preserving the fail-open-to-Integration behavior for
+ * surfaces mounted without one. Never hangs: after
+ * EXECUTION_ROUTING_SETTLE_TIMEOUT_MS the barrier disarms and every parked
+ * executor fails open.
+ */
+function whenExecutionRoutingSettled(timeoutMs = EXECUTION_ROUTING_SETTLE_TIMEOUT_MS) {
+    if (isExecutionRoutingSettled() || !state.descriptorResolving) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            console.warn(`Query execution routing did not settle within ${timeoutMs}ms; executing via Integration`);
+            releaseQueryExecutionResolving();
+        }, timeoutMs);
+        state.descriptorWaiters.push(() => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+/**
+ * Deliberately not persisted (session/local storage): ForceIntegration's
+ * kill-switch semantics rely on a fresh descriptor fetch per page load.
+ * Also advances the boot barrier — a null or integration write settles it
+ * outright (eligibility is irrelevant on that path); a direct write settles it
+ * once the bulk eligibility registration has landed too.
+ */
+function setQueryExecutionDescriptor(descriptor) {
+    state.queryExecution = descriptor !== null && descriptor !== void 0 ? descriptor : null;
+    state.descriptorKnown = true;
+    releaseBarrierIfSettled();
+}
+function getQueryExecutionDescriptor() {
+    return state.queryExecution;
+}
+/**
+ * apiMethodIds of the catalog's direct-eligible promoted base operations — the
+ * per-query half of the routing rule. Populated by the enterprise library from
+ * the promoted-method catalog it already fetches at startup. This bulk write
+ * (an empty list on a failed catalog fetch included) is the boot barrier's
+ * eligibility-known signal; the additive per-entity writes below are not — they
+ * cover one entity, so releasing every parked query on them would wrongly send
+ * the others to Integration.
+ */
+function setDirectEligibleApiMethodIds(apiMethodIds) {
+    state.directEligibleApiMethodIds = (apiMethodIds !== null && apiMethodIds !== void 0 ? apiMethodIds : []).filter((id) => !!id);
+    state.eligibilityKnown = true;
+    releaseBarrierIfSettled();
+}
+function getDirectEligibleApiMethodIds() {
+    return state.directEligibleApiMethodIds;
+}
+/**
+ * Additively merges apiMethodIds into the eligible set. Used by the per-entity
+ * promoted-method fetches so a page's own entity is registered by the same
+ * response that arms its grid — closing the startup race against the bulk
+ * catalog fetch (which still replaces the full list when it lands).
+ */
+function addDirectEligibleApiMethodIds(apiMethodIds) {
+    const incoming = (apiMethodIds !== null && apiMethodIds !== void 0 ? apiMethodIds : []).filter((id) => !!id);
+    if (!incoming.length) {
+        return;
+    }
+    state.directEligibleApiMethodIds = Array.from(new Set([...state.directEligibleApiMethodIds, ...incoming]));
+}
+/**
+ * The one place the whole routing rule lives: direct only when the descriptor
+ * says direct, carries a product URL, and the query's apiMethodId maps to a
+ * direct-eligible promoted base operation. Anything else — including an unset
+ * descriptor from a backend that predates the field — resolves to the
+ * Integration path. On direct failure the executor seams apply the narrow
+ * {@link shouldFallBackToIntegration} contract (501/503, markerless 404); every
+ * other failure surfaces, and ForceIntegration on the product version remains
+ * the operational recovery path.
+ */
+function resolveExecutionTarget(apiMethodId) {
+    const descriptor = state.queryExecution;
+    if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.mode) === 'direct' &&
+        descriptor.url &&
+        apiMethodId &&
+        !isIntegrationOnly(apiMethodId) &&
+        state.directEligibleApiMethodIds.includes(apiMethodId)) {
+        const url = trimTrailingSlashes(descriptor.url);
+        return { mode: 'direct', url, requestUrl: buildDirectAdhocRequestUrl(url, apiMethodId) };
+    }
+    return { mode: 'integration' };
+}
+
 // Function for the first API call
 const getApiCatalogAndProduct = async () => {
     const { baseURL } = await getBaseUrls();
@@ -276,7 +609,7 @@ let prefetchedQueryAdHoc;
 const executeQueryAdHoc = (data, apiMethodId, apiBase, prefetch = false) => {
     const args = [data, apiMethodId, tenantUtils.getCurrentTenantId(), apiBase != 'hotlist'];
     if (!prefetch && prefetchedQueryAdHoc) {
-        if (deepEqual__default.default(prefetchedQueryAdHoc.args, args)) {
+        if (isEqual__default.default(prefetchedQueryAdHoc.args, args)) {
             const { response } = prefetchedQueryAdHoc;
             console.info(`Using prefetch for /apimethod/executeQueryAdHoc/${apiMethodId} prefetch`, prefetchedQueryAdHoc.args, args);
             prefetchedQueryAdHoc = undefined;
@@ -287,11 +620,25 @@ const executeQueryAdHoc = (data, apiMethodId, apiBase, prefetch = false) => {
             prefetchedQueryAdHoc = undefined;
         }
     }
-    const response = getBaseUrls().then(({ baseURL, baseURLHost }) => {
-        const url = apiBase != 'hotlist'
-            ? `${baseURL}/apimethod/executeQueryAdHoc/${apiMethodId}`
-            : `${baseURLHost}/UdpHotList/containingRecord`;
-        return makeApiCall.makeApiCall('POST', url, data);
+    const response = getBaseUrls().then(async ({ baseURL, baseURLHost }) => {
+        // Direct-if-eligible routing (UNT-6403): when the tenant x product execution
+        // descriptor says "direct" and this apiMethodId maps to a direct-eligible
+        // promoted base operation, the ad hoc query executes against the product's
+        // UdpQuery endpoint, with the narrow Integration fallback for builds whose
+        // runtime predates the operation. The boot barrier holds a page's first
+        // queries until the provider's descriptor fetch settles, so a reload does
+        // not silently route them to Integration.
+        if (apiBase != 'hotlist') {
+            await whenExecutionRoutingSettled();
+        }
+        const target = apiBase != 'hotlist' ? resolveExecutionTarget(apiMethodId) : { mode: 'integration' };
+        const integrationUrl = apiBase == 'hotlist'
+            ? `${baseURLHost}/UdpHotList/containingRecord`
+            : `${baseURL}/apimethod/executeQueryAdHoc/${apiMethodId}`;
+        if (target.mode === 'direct') {
+            return directCallWithIntegrationFallback(() => makeApiCall.makeApiCall('POST', target.requestUrl, data), () => makeApiCall.makeApiCall('POST', integrationUrl, data), apiMethodId);
+        }
+        return makeApiCall.makeApiCall('POST', integrationUrl, data);
     });
     if (prefetch) {
         console.info(`Prefetching /apimethod/executeQueryAdHoc/${apiMethodId}`);
@@ -311,10 +658,31 @@ const getApiCatalogById = async (apiCatalogId) => {
 const executeQueryWithParameters = async (data, apiMethodId) => {
     console.log('executeQueryWithParameters called', apiMethodId);
     const { baseURL } = await getBaseUrls();
-    console.log('baseURL from External config:', baseURL);
-    const url = `${baseURL}/apimethod/executeQueryWithParameters/${apiMethodId}`;
-    const response = await makeApiCall.makeApiCall('POST', url, data);
-    return response; // return the response data
+    const integrationUrl = `${baseURL}/apimethod/executeQueryWithParameters/${apiMethodId}`;
+    // Direct-if-eligible routing (UNT-6403): the request body contract is identical
+    // on both paths (a flat name→value map plus an optional requestBody entry).
+    // Boot barrier: see executeQueryAdHoc.
+    await whenExecutionRoutingSettled();
+    const target = resolveExecutionTarget(apiMethodId);
+    if (target.mode === 'direct') {
+        return directCallWithIntegrationFallback(() => makeApiCall.makeApiCall('POST', buildDirectExecuteWithParametersUrl(target.url, apiMethodId), data), () => makeApiCall.makeApiCall('POST', integrationUrl, data), apiMethodId, { mayWrite: true });
+    }
+    return makeApiCall.makeApiCall('POST', integrationUrl, data);
+};
+/**
+ * Ad hoc execution against a caller-resolved direct UdpQuery URL, for callers
+ * that route outside the hosting product's execution store (e.g. Data Builder,
+ * which builds queries against any product). Applies the same migration-window
+ * fallback contract as executeQueryAdHoc, with Integration's ad hoc endpoint
+ * for this apiMethodId as the fallback target.
+ */
+const executeDirectQueryAdHoc = async (data, apiMethodId, directRequestUrl) => {
+    const { baseURL } = await getBaseUrls();
+    const integrationUrl = `${baseURL}/apimethod/executeQueryAdHoc/${apiMethodId}`;
+    if (isIntegrationOnly(apiMethodId)) {
+        return makeApiCall.makeApiCall('POST', integrationUrl, data);
+    }
+    return directCallWithIntegrationFallback(() => makeApiCall.makeApiCall('POST', directRequestUrl, data), () => makeApiCall.makeApiCall('POST', integrationUrl, data), apiMethodId);
 };
 class QueryResult {
     constructor() {
@@ -370,7 +738,9 @@ function getCleanData(data, lookupsMap) {
                     const keys = (_a = lookup.udpLookupUdpLookupKey) !== null && _a !== void 0 ? _a : (lookup.keyName ? [{ name: lookup.keyName }] : []);
                     let temp = (_b = lookup === null || lookup === void 0 ? void 0 : lookup.data) === null || _b === void 0 ? void 0 : _b.find(item => item[lookup.valueName] === currentValue);
                     if (temp != null)
-                        keys.forEach(k => { cleanData[index][k.name] = temp[k.name]; });
+                        keys.forEach(k => {
+                            cleanData[index][k.name] = temp[k.name];
+                        });
                 });
             }
             else if (cleanData[attribute]) {
@@ -379,7 +749,9 @@ function getCleanData(data, lookupsMap) {
                 const keys = (_a = lookup.udpLookupUdpLookupKey) !== null && _a !== void 0 ? _a : (lookup.keyName ? [{ name: lookup.keyName }] : []);
                 let temp = lookup.data.find(item => item[lookup.valueName] === currentValue);
                 if (temp != null)
-                    keys.forEach(k => { cleanData[k.name] = temp[k.name]; });
+                    keys.forEach(k => {
+                        cleanData[k.name] = temp[k.name];
+                    });
                 /* eslint-enable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
             }
         });
@@ -627,11 +999,20 @@ const removeRecordFromHotlist = async (hotlistID) => {
     return makeApiCall.makeApiCall('DELETE', url, null, true);
 };
 
+exports.DIRECT_ELIGIBLE_BASE_OPERATION_TYPE_IDS = DIRECT_ELIGIBLE_BASE_OPERATION_TYPE_IDS;
+exports.EXECUTION_ROUTING_SETTLE_TIMEOUT_MS = EXECUTION_ROUTING_SETTLE_TIMEOUT_MS;
+exports.UDP_QUERY_RUNTIME_MARKER_HEADER = UDP_QUERY_RUNTIME_MARKER_HEADER;
+exports.addDirectEligibleApiMethodIds = addDirectEligibleApiMethodIds;
 exports.addRecordToAHotlist = addRecordToAHotlist;
+exports.buildDirectAdhocRequestUrl = buildDirectAdhocRequestUrl;
+exports.buildDirectExecuteInstanceUrl = buildDirectExecuteInstanceUrl;
+exports.buildDirectExecuteWithParametersUrl = buildDirectExecuteWithParametersUrl;
 exports.createAHotlist = createAHotlist;
 exports.createStore = createStore;
 exports.deleteAHotlist = deleteAHotlist;
 exports.deleteSelectedView = deleteSelectedView;
+exports.directCallWithIntegrationFallback = directCallWithIntegrationFallback;
+exports.executeDirectQueryAdHoc = executeDirectQueryAdHoc;
 exports.executeQueryAdHoc = executeQueryAdHoc;
 exports.executeQueryAdHocAndMapLookups = executeQueryAdHocAndMapLookups;
 exports.executeQueryWithParameters = executeQueryWithParameters;
@@ -643,12 +1024,25 @@ exports.getApiMethodInstance = getApiMethodInstance;
 exports.getAvailableGridActions = getAvailableGridActions;
 exports.getAvailableViews = getAvailableViews;
 exports.getCleanData = getCleanData;
+exports.getDirectEligibleApiMethodIds = getDirectEligibleApiMethodIds;
 exports.getGridViewsWithConfigurations = getGridViewsWithConfigurations;
+exports.getIntegrationFallbackStatus = getIntegrationFallbackStatus;
 exports.getPromotedLookupMethod = getPromotedLookupMethod;
 exports.getPromotedMethodEntities = getPromotedMethodEntities;
+exports.getQueryExecutionDescriptor = getQueryExecutionDescriptor;
 exports.getSelectedView = getSelectedView;
+exports.isIntegrationOnly = isIntegrationOnly;
 exports.loadAHotlist = loadAHotlist;
+exports.markIntegrationOnly = markIntegrationOnly;
+exports.markQueryExecutionResolving = markQueryExecutionResolving;
+exports.releaseQueryExecutionResolving = releaseQueryExecutionResolving;
 exports.removeRecordFromHotlist = removeRecordFromHotlist;
+exports.resetQueryExecutionRouting = resetQueryExecutionRouting;
+exports.resolveExecutionTarget = resolveExecutionTarget;
 exports.saveView = saveView;
+exports.setDirectEligibleApiMethodIds = setDirectEligibleApiMethodIds;
+exports.setQueryExecutionDescriptor = setQueryExecutionDescriptor;
+exports.shouldFallBackToIntegration = shouldFallBackToIntegration;
 exports.updateView = updateView;
 exports.updateViewAndConfigurations = updateViewAndConfigurations;
+exports.whenExecutionRoutingSettled = whenExecutionRoutingSettled;

package/dist/cjs/{catalog-store-CrTx8FL-.js → catalog-store-B_YMkXRh.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var apiUtils = require('./apiUtils-DMOOqk3y.js');
+var apiUtils = require('./apiUtils-0pkNuvqf.js');
 
 // src/global/state.ts
 const { state, onChange } = apiUtils.createStore({

package/dist/cjs/{configureUdpColumnMods-CongQl55.js → configureUdpColumnMods-BT7UbQPh.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var lookupHelper = require('./lookupHelper-DPnaYUT4.js');
+var lookupHelper = require('./lookupHelper-ClpMWN_g.js');
 
 /**
  * Finds an existing 'actions' column in an array of ColDefs and applies