@memberjunction/react-test-harness 6.2.0-edge.6 → 6.2.0-edge.7

package/dist/lib/component-runner.js

@@ -131,6 +131,10 @@ export function ResolveDataCapMaxRows(requested, ceiling) {
  * paging, making it the denominator for "capped at N of M". Providers that omit it, or
  * leave it equal to `RowCount`, yield `capped: false` rather than a guess.
  *
+ * A result with `Success: false` is a failed call, not an empty one: its `ErrorMessage` is
+ * recorded as `error`. Providers return a client-database timeout this way rather than
+ * throwing, and recording it as a 0-row success reads as "no data" downstream.
+ *
  * Pure (no I/O) so it can be unit-tested without launching a browser.
  */
 export function BuildDataAccessRecord(kind, resolved, result, maxRows, durationMs) {
@@ -146,7 +150,58 @@ export function BuildDataAccessRecord(kind, resolved, result, maxRows, durationM
         appliedMaxRows: maxRows.applied,
         requestedMaxRows: maxRows.requested,
         durationMs,
+        ...(result?.Success === false && { error: result.ErrorMessage || 'the call failed with no error message' }),
+    };
+}
+/** Start time of each data call that has not returned yet. */
+const pendingDataCalls = new WeakMap();
+/** Records that are final: returned, or reported as still running when the test ended. */
+const settledDataCalls = new WeakSet();
+/**
+ * Adds a record for a data call as it starts, so a call still running when the test ends is
+ * reported instead of missing. {@link SettleDataAccessRecord} fills it in when the call returns;
+ * {@link FinalizePendingDataAccess} marks it if it has not by the time the result is built.
+ */
+export function StartDataAccessRecord(dataAccess, kind, resolved, maxRows, now = Date.now()) {
+    const record = {
+        kind,
+        target: resolved.target,
+        identity: resolved.identity,
+        rowsReturned: 0,
+        capped: false,
+        appliedMaxRows: maxRows.applied,
+        requestedMaxRows: maxRows.requested,
+        durationMs: 0,
     };
+    pendingDataCalls.set(record, now);
+    dataAccess.push(record);
+    return record;
+}
+/**
+ * Completes a started record with the call's outcome. A record already reported as still running
+ * is left as it was: the result the caller received said so, and must not change afterwards.
+ */
+export function SettleDataAccessRecord(placeholder, outcome) {
+    if (settledDataCalls.has(placeholder))
+        return;
+    pendingDataCalls.delete(placeholder);
+    settledDataCalls.add(placeholder);
+    Object.assign(placeholder, outcome);
+}
+/**
+ * Marks every call still running when the test finishes as failed, with how long it had run.
+ * Without this, a slow query reads as "the component made no data calls".
+ */
+export function FinalizePendingDataAccess(dataAccess, now = Date.now()) {
+    for (const record of dataAccess) {
+        const startedAt = pendingDataCalls.get(record);
+        if (startedAt === undefined)
+            continue;
+        pendingDataCalls.delete(record);
+        settledDataCalls.add(record);
+        record.durationMs = now - startedAt;
+        record.error = `still running after ${(record.durationMs / 1000).toFixed(1)}s when the test finished`;
+    }
 }
 /** Debug-log suffix naming the cap, e.g. ` (capped at 1000 of 205802)`. Empty when uncapped. */
 export function DescribeDataCap(record) {
@@ -157,7 +212,14 @@ export function DescribeDataCap(record) {
  * `/MJ/AI/Agents/Foo`. Tolerates missing or doubled slashes on either side.
  */
 function joinCategoryPath(categoryPath, name) {
-    const trimmed = categoryPath.replace(/^\/+|\/+$/g, '');
+    // Trimmed by scanning rather than /^\/+|\/+$/g, which backtracks quadratically on long runs of '/'
+    let start = 0;
+    let end = categoryPath.length;
+    while (start < end && categoryPath[start] === '/')
+        start++;
+    while (end > start && categoryPath[end - 1] === '/')
+        end--;
+    const trimmed = categoryPath.slice(start, end);
     return trimmed.length === 0 ? `/${name}` : `/${trimmed}/${name}`;
 }
 /**
@@ -236,6 +298,12 @@ export function ResolveViewTarget(params) {
 export function DescribeViewTarget(params) {
     return ResolveViewTarget(params).target;
 }
+/**
+ * Rule for a call to a component utility the harness was not given (for example
+ * `utilities.ai` when the caller passes no AI tools). The call cannot be tested here,
+ * which is a limit of the harness, not a defect in the component.
+ */
+export const SANDBOX_UTILITY_UNAVAILABLE_RULE = 'sandbox-utility-unavailable';
 /**
  * ComponentRunner that uses the actual React runtime via Playwright UMD bundle
  */
@@ -276,6 +344,94 @@ export class ComponentRunner {
         const lowerMessage = message.toLowerCase();
         return ComponentRunner.BROWSER_CRASH_PATTERNS.some(pattern => lowerMessage.includes(pattern));
     }
+    /**
+     * Occurrences of one JSX element-type error at which it stops being treated as noise and
+     * fails the run.
+     *
+     * These errors can be spurious: a child component that resolves a moment late produces one
+     * or two before settling, which is why they were once dropped entirely. But dropping them
+     * has no limit. A component rendering an object where a component belongs throws one per
+     * render, and runs have reached thousands in a single component while reporting success.
+     * A handful is a race; a few dozen is a defect.
+     */
+    static { this.JSX_ERROR_FAILURE_THRESHOLD = 25; }
+    /** Whether `e` is an "invalid JSX element type" or "undefined component" error. */
+    static isJSXElementError(e) {
+        return e.type === 'invalid-element-type' || e.type === 'undefined-component' ||
+            e.rule === 'invalid-jsx-element' || e.rule === 'undefined-jsx-component';
+    }
+    /** A JSX element-type error rare enough to be treated as a transient resolution miss. */
+    static isSuppressibleJSXError(e) {
+        return ComponentRunner.isJSXElementError(e) && e.occurrences < ComponentRunner.JSX_ERROR_FAILURE_THRESHOLD;
+    }
+    /**
+     * Folds an error from the second (post-async) collection into the first. Collection is
+     * cumulative, so a JSX error seen again carries a higher count and a different message: it
+     * replaces its earlier entry instead of being added beside it, and it counts toward the
+     * run's errors once it reaches the threshold.
+     */
+    static mergeAsyncRuntimeError(err, errors, collected) {
+        if (!ComponentRunner.isJSXElementError(err)) {
+            if (!errors.includes(err.message)) {
+                errors.push(err.message);
+                collected.push(err);
+            }
+            return;
+        }
+        const index = collected.findIndex(e => e.type === err.type && e.baseMessage === err.baseMessage);
+        if (index >= 0) {
+            const previousMessage = errors.indexOf(collected[index].message);
+            if (previousMessage >= 0)
+                errors.splice(previousMessage, 1);
+            collected[index] = err;
+        }
+        else {
+            collected.push(err);
+        }
+        if (!ComponentRunner.isSuppressibleJSXError(err))
+            errors.push(err.message);
+    }
+    /**
+     * The reported violation for a collected runtime error. Most are critical. A JSX
+     * element-type error is low below the threshold, so it stays visible without failing the
+     * run, and high at or above it, which fails `codeExecutionSuccess`.
+     */
+    static buildRuntimeErrorViolation(e, debug) {
+        const isJSXError = ComponentRunner.isJSXElementError(e);
+        const isFailingJSXError = isJSXError && !ComponentRunner.isSuppressibleJSXError(e);
+        const severity = !isJSXError ? 'critical' : isFailingJSXError ? 'high' : 'low';
+        if (isJSXError && debug) {
+            console.log(`📝 JSX element error (${e.occurrences}x, severity=${severity}):`, e.message);
+        }
+        return {
+            message: isFailingJSXError
+                ? `${e.message} — repeated ${e.occurrences} times, which indicates a genuinely invalid element type rather than a transient resolution miss`
+                : e.message,
+            severity,
+            rule: e.rule || 'runtime-error', // Use specific rule from collectRuntimeErrors
+            line: 0,
+            column: 0,
+            source: e.source,
+            stack: e.stack,
+            componentStack: e.componentStack,
+        };
+    }
+    /**
+     * One warning per utility the component called that this harness was not given. They are
+     * warnings rather than errors so they never fail the run or reach a fixer as a defect:
+     * the call was not tested, and the component may well be correct.
+     */
+    static buildUnavailableUtilityWarnings(unavailableUtilities) {
+        return [...unavailableUtilities].map(name => ({
+            message: `${name} is not available in the test harness, so this call was not tested. ` +
+                `This is a limit of the harness, not a defect in the component.`,
+            severity: 'medium',
+            rule: SANDBOX_UTILITY_UNAVAILABLE_RULE,
+            line: 0,
+            column: 0,
+            source: 'test-harness'
+        }));
+    }
     /**
      * Reclassify violations that are actually browser crashes.
      * Browser crashes should be marked as low severity with rule='browser-crash'
@@ -321,6 +477,7 @@ export class ComponentRunner {
         const warnings = [];
         const consoleLogs = [];
         const dataErrors = []; // Track data access errors from RunView/RunQuery
+        const unavailableUtilities = new Set(); // Utilities the component called that this harness was not given
         const dataAccess = []; // Track every data call: target, rows, cap state
         let renderCount = 0;
         const debug = options.debug !== false; // Default to true for debugging
@@ -391,7 +548,7 @@ export class ComponentRunner {
             // Set up console logging
             this.setupConsoleLogging(page, consoleLogs, warnings);
             // Expose MJ utilities to the page
-            await this.exposeMJUtilities(page, options, dataErrors, dataAccess, debug);
+            await this.exposeMJUtilities(page, options, dataErrors, unavailableUtilities, dataAccess, debug);
             if (debug) {
                 console.log('📤 NODE: About to call page.evaluate with:');
                 console.log('  - spec.name:', options.componentSpec.name);
@@ -427,11 +584,21 @@ export class ComponentRunner {
                 }
                 // Declare renderCheckInterval at the top scope for cleanup
                 let renderCheckInterval;
+                const harnessWindow = window;
+                // A failure the harness can name is thrown with that name, so the catch below can
+                // report it under its own rule instead of the catch-all 'execution-error'.
+                // HarnessSetupError: the page itself is not ready, so the component never ran.
+                // ComponentLoadError: the component compiled but did not yield a usable root.
+                const namedError = (name, message) => {
+                    const error = new Error(message);
+                    error.name = name;
+                    return error;
+                };
                 try {
                     // Access the real runtime classes
                     const MJRuntime = window.MJReactRuntime;
                     if (!MJRuntime) {
-                        throw new Error('React runtime not loaded');
+                        throw namedError('HarnessSetupError', 'React runtime not loaded');
                     }
                     const { ComponentCompiler, ComponentRegistry, ComponentHierarchyRegistrar, ComponentManager, SetupStyles, ApplyStyleOverrides } = MJRuntime;
                     if (debug) {
@@ -461,7 +628,7 @@ export class ComponentRunner {
                     if (!window.React) {
                         console.error('🔴 CRITICAL: React is NULL when creating runtimeContext!');
                         console.error('Window keys:', Object.keys(window).filter(k => k.toLowerCase().includes('react')));
-                        throw new Error('React is not available in window context');
+                        throw namedError('HarnessSetupError', 'React is not available in window context');
                     }
                     if (debug) {
                         console.log('✅ React is available:', typeof window.React);
@@ -506,7 +673,7 @@ export class ComponentRunner {
                     // Don't call createRuntimeUtilities() as it tries to create new Metadata() which fails
                     const utilities = window.__mjUtilities;
                     if (!utilities) {
-                        throw new Error('Utilities not found - exposeMJUtilities may have failed');
+                        throw namedError('HarnessSetupError', 'Utilities not found - exposeMJUtilities may have failed');
                     }
                     // The test harness renders components in isolation without the MJExplorer
                     // chrome, so there are no `--mj-*` theme tokens on the page to bridge from.
@@ -645,7 +812,25 @@ export class ComponentRunner {
                         console.log('❌ Registration failed:', registrationResult.errors);
                     }
                     if (!registrationResult.success) {
-                        throw new Error('Component registration failed: ' + JSON.stringify(registrationResult.errors));
+                        // One entry per failed component, naming it and the phase that failed, so
+                        // unrelated failures are reported (and grouped by consumers) separately.
+                        const failures = registrationResult.errors;
+                        harnessWindow.__testHarnessRuntimeErrors = harnessWindow.__testHarnessRuntimeErrors || [];
+                        for (const failure of failures) {
+                            const who = failure.componentName ? `Component "${failure.componentName}"` : 'A component';
+                            harnessWindow.__testHarnessRuntimeErrors.push({
+                                message: `${who} failed during ${failure.phase || 'registration'}: ${failure.error || 'no error message was reported'}`,
+                                type: 'registration-error',
+                                phase: failure.phase,
+                                source: 'runtime-wrapper'
+                            });
+                        }
+                        harnessWindow.__testHarnessTestFailed = true;
+                        return {
+                            success: false,
+                            error: `Component registration failed for ${failures.length} component(s)`,
+                            componentCount: 0
+                        };
                     }
                     if (debug) {
                         console.log('📝 Registered components:', registrationResult.registeredComponents);
@@ -654,19 +839,19 @@ export class ComponentRunner {
                     }
                     // NEW: With ComponentManager, we already have the components from loadResult
                     if (!loadResult) {
-                        throw new Error('Component loading failed - no result returned');
+                        throw namedError('ComponentLoadError', 'Component loading failed - no result returned');
                     }
                     const RootComponentObject = loadResult.rootComponent;
                     if (!RootComponentObject) {
                         // Enhanced error message with debugging info
                         console.error('Failed to load component:', spec.name);
                         console.error('Load errors:', loadResult.errors);
-                        throw new Error('Root component not loaded: ' + spec.name);
+                        throw namedError('ComponentLoadError', `Root component "${spec.name}" was not loaded`);
                     }
                     // Extract the React component from the ComponentObject
                     const RootComponent = RootComponentObject.component;
                     if (!RootComponent || typeof RootComponent !== 'function') {
-                        throw new Error('Component object does not contain a valid React component');
+                        throw namedError('ComponentLoadError', `Component "${spec.name}" does not contain a valid React component`);
                     }
                     // Get all loaded components from the result
                     // ComponentManager now returns unwrapped components directly
@@ -710,6 +895,11 @@ export class ComponentRunner {
                         window.__testHarnessRenderCount = window.__testHarnessRenderCount || 0;
                         // Wrap React.createElement to detect invalid element types
                         const originalCreateElement = window.React?.createElement;
+                        // React.memo, forwardRef, lazy and context providers/consumers are objects tagged
+                        // with one of these symbols, and are valid element types. Library components are
+                        // often built this way, so treating every object as invalid flagged working code.
+                        const reactComponentObjectTags = new Set(['react.memo', 'react.forward_ref', 'react.lazy', 'react.provider', 'react.context', 'react.consumer']
+                            .map(tag => Symbol.for(tag)));
                         if (originalCreateElement) {
                             window.React.createElement = function (type, props, ...children) {
                                 window.__testHarnessRenderCount++;
@@ -717,7 +907,8 @@ export class ComponentRunner {
                                 if (type !== null && type !== undefined) {
                                     const typeOf = typeof type;
                                     // Check for the common "object instead of component" error
-                                    if (typeOf === 'object' && !window.React.isValidElement(type)) {
+                                    if (typeOf === 'object' && !window.React.isValidElement(type) &&
+                                        !reactComponentObjectTags.has(type.$$typeof)) {
                                         // Try to get a meaningful name for the object
                                         let objectInfo = 'unknown object';
                                         try {
@@ -965,14 +1156,16 @@ export class ComponentRunner {
                     console.error('🔴 BROWSER: Error stack:', error.stack);
                     console.error('🔴 BROWSER: Error type:', typeof error);
                     console.error('🔴 BROWSER: Error stringified:', JSON.stringify(error, null, 2));
-                    window.__testHarnessRuntimeErrors = window.__testHarnessRuntimeErrors || [];
-                    window.__testHarnessRuntimeErrors.push({
+                    const isSetupError = error?.name === 'HarnessSetupError';
+                    const isLoadError = error?.name === 'ComponentLoadError';
+                    harnessWindow.__testHarnessRuntimeErrors = harnessWindow.__testHarnessRuntimeErrors || [];
+                    harnessWindow.__testHarnessRuntimeErrors.push({
                         message: error.message || String(error),
                         stack: error.stack,
-                        type: 'execution-error',
-                        source: 'runtime-wrapper'
+                        type: isSetupError ? 'harness-setup-error' : isLoadError ? 'component-load-error' : 'execution-error',
+                        source: isSetupError ? 'test-harness' : 'runtime-wrapper'
                     });
-                    window.__testHarnessTestFailed = true;
+                    harnessWindow.__testHarnessTestFailed = true;
                     return {
                         success: false,
                         error: error.message || String(error)
@@ -1051,14 +1244,9 @@ export class ComponentRunner {
             renderCount = await page.evaluate(() => window.__testHarnessRenderCount || 0);
             // Collect all errors with source information
             const runtimeErrorsWithSource = await this.collectRuntimeErrors(page);
-            // Filter out JSX element type errors when adding to errors array
+            // Low-volume JSX element-type errors stay out of the error count (see JSX_ERROR_FAILURE_THRESHOLD)
             errors.push(...runtimeErrorsWithSource
-                .filter(e => {
-                // Skip JSX element type errors from error count
-                const isJSXError = e.type === 'invalid-element-type' ||
-                    e.type === 'undefined-component';
-                return !isJSXError;
-            })
+                .filter(e => !ComponentRunner.isSuppressibleJSXError(e))
                 .map(e => e.message)); // Extract messages for backward compat
             // Collect warnings (separate from errors)
             const collectedWarnings = await this.collectWarnings(page);
@@ -1067,19 +1255,7 @@ export class ComponentRunner {
             const asyncWaitTime = options.asyncErrorWaitTime || 1000;
             await page.waitForTimeout(asyncWaitTime);
             const asyncErrors = await this.collectRuntimeErrors(page);
-            // Only add new errors (excluding JSX element type errors)
-            asyncErrors.forEach(err => {
-                const isJSXError = err.type === 'invalid-element-type' ||
-                    err.type === 'undefined-component';
-                if (!isJSXError && !errors.includes(err.message)) {
-                    errors.push(err.message);
-                    runtimeErrorsWithSource.push(err); // Keep the structured version too
-                }
-                else if (isJSXError && !runtimeErrorsWithSource.some(e => e.message === err.message)) {
-                    // Still track JSX errors for logging but don't add to errors array
-                    runtimeErrorsWithSource.push(err);
-                }
-            });
+            asyncErrors.forEach(err => ComponentRunner.mergeAsyncRuntimeError(err, errors, runtimeErrorsWithSource));
             // Also check for new warnings
             const asyncWarnings = await this.collectWarnings(page);
             asyncWarnings.forEach(warn => {
@@ -1190,30 +1366,10 @@ export class ComponentRunner {
                 executionResult.success;
             // Combine runtime errors with data errors
             const allErrors = [...errors, ...dataErrors];
-            // Map runtime errors with source info and specific rules
-            // Filter out JSX element type errors - they're too noisy and often false positives
+            // Map runtime errors with source info and specific rules. JSX element-type errors are
+            // graded by volume rather than dropped (see JSX_ERROR_FAILURE_THRESHOLD).
             const errorViolations = runtimeErrorsWithSource
-                .filter(e => {
-                // Skip JSX element type errors - still logged but not reported as violations
-                const isJSXError = e.rule === 'invalid-jsx-element' ||
-                    e.rule === 'undefined-jsx-component' ||
-                    e.type === 'invalid-element-type' ||
-                    e.type === 'undefined-component';
-                if (isJSXError && debug) {
-                    console.log('📝 JSX element error detected but not reported as violation:', e.message);
-                }
-                return !isJSXError;
-            })
-                .map(e => ({
-                message: e.message,
-                severity: 'critical',
-                rule: e.rule || 'runtime-error', // Use specific rule from collectRuntimeErrors
-                line: 0,
-                column: 0,
-                source: e.source,
-                stack: e.stack,
-                componentStack: e.componentStack,
-            }));
+                .map(e => ComponentRunner.buildRuntimeErrorViolation(e, debug));
             // Add timeout error if detected
             if (hasTimeout) {
                 errorViolations.push({
@@ -1275,6 +1431,7 @@ export class ComponentRunner {
             // Medium, low, and warning severity don't affect this metric
             const nonCrashCriticalHighErrors = allErrorViolations.filter(e => (e.severity === 'critical' || e.severity === 'high') && e.rule !== 'browser-crash');
             const codeExecutionSuccess = nonCrashCriticalHighErrors.length === 0;
+            FinalizePendingDataAccess(dataAccess);
             // Surface capped data calls as their own warnings, so a downstream evaluator does not
             // read a deliberately truncated render as a defect.
             const capWarnings = dataAccess
@@ -1302,6 +1459,7 @@ export class ComponentRunner {
                         column: 0
                     })),
                     ...capWarnings,
+                    ...ComponentRunner.buildUnavailableUtilityWarnings(unavailableUtilities),
                 ],
                 console: consoleLogs,
                 screenshot,
@@ -1364,17 +1522,21 @@ export class ComponentRunner {
             // Medium, low, and warning severity don't affect this metric
             const nonCrashCriticalHighErrors = errorViolations.filter(e => (e.severity === 'critical' || e.severity === 'high') && e.rule !== 'browser-crash');
             const codeExecutionSuccess = nonCrashCriticalHighErrors.length === 0;
+            FinalizePendingDataAccess(dataAccess);
             const result = {
                 success: false,
                 html: '',
                 errors: errorViolations,
-                warnings: warnings.map(w => ({
-                    message: w,
-                    severity: 'low',
-                    rule: 'warning',
-                    line: 0,
-                    column: 0
-                })),
+                warnings: [
+                    ...warnings.map(w => ({
+                        message: w,
+                        severity: 'low',
+                        rule: 'warning',
+                        line: 0,
+                        column: 0
+                    })),
+                    ...ComponentRunner.buildUnavailableUtilityWarnings(unavailableUtilities),
+                ],
                 console: consoleLogs,
                 executionTime: Date.now() - startTime,
                 renderCount,
@@ -1877,6 +2039,12 @@ export class ComponentRunner {
                 case 'execution-error':
                     rule = 'execution-error';
                     break;
+                case 'harness-setup-error':
+                    rule = 'harness-setup-error';
+                    break;
+                case 'component-load-error':
+                    rule = 'component-load-error';
+                    break;
                 case 'runtime':
                     rule = 'runtime-error';
                     break;
@@ -1932,7 +2100,10 @@ export class ComponentRunner {
                 : error.message;
             errors.push({
                 ...error,
-                message
+                message,
+                baseMessage: error.message,
+                // Carried as a field, not only in the message, so severity can threshold on volume
+                occurrences: count
             });
         });
         return errors;
@@ -2129,7 +2300,7 @@ export class ComponentRunner {
                     // Generate embeddings for all texts
                     const embeddings = [];
                     for (const text of texts) {
-                        const result = await aiEngine.EmbedText(model, text);
+                        const result = await aiEngine.EmbedText(model, text, undefined, { inputType: params.inputType });
                         if (result && result.vector) {
                             embeddings.push(result.vector);
                         }
@@ -2158,7 +2329,7 @@ export class ComponentRunner {
     /**
      * Expose MJ utilities to the browser context
      */
-    async exposeMJUtilities(page, options, dataErrors, dataAccess, debug = false) {
+    async exposeMJUtilities(page, options, dataErrors, unavailableUtilities, dataAccess, debug = false) {
         // Row ceilings for this run, resolved once rather than per call.
         const viewCeiling = options.dataCaps?.runViewMaxRows ?? DEFAULT_RUN_VIEW_MAX_ROWS;
         const queryCeiling = options.dataCaps?.runQueryMaxRows ?? DEFAULT_RUN_QUERY_MAX_ROWS;
@@ -2252,13 +2423,16 @@ export class ComponentRunner {
             const viewTarget = ResolveViewTarget(params);
             const maxRows = ResolveDataCapMaxRows(params.MaxRows, viewCeiling);
             const startedAt = Date.now();
+            const placeholder = StartDataAccessRecord(dataAccess, 'RunView', viewTarget, maxRows, startedAt);
             try {
                 const result = await util.rv.RunView({ ...params, MaxRows: maxRows.applied }, options.contextUser);
                 const record = BuildDataAccessRecord('RunView', viewTarget, result, maxRows, Date.now() - startedAt);
-                dataAccess.push(record);
-                // Debug logging for successful calls
+                SettleDataAccessRecord(placeholder, record);
+                // Debug logging for completed calls
                 if (debug) {
-                    console.log(`💾 RunView SUCCESS: View="${viewTarget.target}" Rows=${record.rowsReturned}${DescribeDataCap(record)}`);
+                    console.log(record.error
+                        ? `❌ RunView FAILED: View="${viewTarget.target}" — ${record.error}`
+                        : `💾 RunView SUCCESS: View="${viewTarget.target}" Rows=${record.rowsReturned}${DescribeDataCap(record)}`);
                     if (params.ExtraFilter) {
                         console.log(`   Filter: ${params.ExtraFilter}`);
                     }
@@ -2267,7 +2441,7 @@ export class ComponentRunner {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                dataAccess.push({
+                SettleDataAccessRecord(placeholder, {
                     kind: 'RunView', target: viewTarget.target, identity: viewTarget.identity, rowsReturned: 0, capped: false,
                     appliedMaxRows: maxRows.applied, requestedMaxRows: maxRows.requested,
                     durationMs: Date.now() - startedAt, error: errorMessage,
@@ -2289,18 +2463,21 @@ export class ComponentRunner {
         await page.exposeFunction('__mjRunViews', async (params) => {
             const perCallMaxRows = params.map(p => ResolveDataCapMaxRows(p.MaxRows, viewCeiling));
             const startedAt = Date.now();
+            const placeholders = params.map((p, i) => StartDataAccessRecord(dataAccess, 'RunViews', ResolveViewTarget(p), perCallMaxRows[i], startedAt));
             try {
                 const results = await util.rv.RunViews(params.map((p, i) => ({ ...p, MaxRows: perCallMaxRows[i].applied })), options.contextUser);
                 // One record per view in the batch — a batch that partially returns data is a
                 // meaningfully different signal from one that returns none.
                 const elapsed = Date.now() - startedAt;
                 const records = params.map((p, i) => BuildDataAccessRecord('RunViews', ResolveViewTarget(p), results[i], perCallMaxRows[i], elapsed));
-                records.forEach(r => dataAccess.push(r));
-                // Debug logging for successful calls
+                records.forEach((r, i) => SettleDataAccessRecord(placeholders[i], r));
+                // Debug logging for completed calls
                 if (debug) {
-                    console.log(`💾 RunViews SUCCESS: ${params.length} queries executed`);
+                    console.log(`💾 RunViews completed: ${params.length} queries executed`);
                     records.forEach((r, i) => {
-                        console.log(`   [${i + 1}] Entity="${r.target}" Rows=${r.rowsReturned}${DescribeDataCap(r)}`);
+                        console.log(r.error
+                            ? `   [${i + 1}] Entity="${r.target}" FAILED — ${r.error}`
+                            : `   [${i + 1}] Entity="${r.target}" Rows=${r.rowsReturned}${DescribeDataCap(r)}`);
                     });
                 }
                 return results;
@@ -2309,7 +2486,7 @@ export class ComponentRunner {
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 const entities = params.map(p => DescribeViewTarget(p)).join(', ');
                 // RunViews fails as a batch, so every view in it failed.
-                params.forEach((p, i) => dataAccess.push({
+                params.forEach((p, i) => SettleDataAccessRecord(placeholders[i], {
                     kind: 'RunViews', ...ResolveViewTarget(p), rowsReturned: 0, capped: false,
                     appliedMaxRows: perCallMaxRows[i].applied, requestedMaxRows: perCallMaxRows[i].requested,
                     durationMs: Date.now() - startedAt, error: errorMessage,
@@ -2332,13 +2509,16 @@ export class ComponentRunner {
             const queryIdentifier = ResolveQueryTarget(params);
             const maxRows = ResolveDataCapMaxRows(params.MaxRows, queryCeiling);
             const startedAt = Date.now();
+            const placeholder = StartDataAccessRecord(dataAccess, 'RunQuery', queryIdentifier, maxRows, startedAt);
             try {
                 const result = await util.rq.RunQuery({ ...params, MaxRows: maxRows.applied }, options.contextUser);
                 const record = BuildDataAccessRecord('RunQuery', queryIdentifier, result, maxRows, Date.now() - startedAt);
-                dataAccess.push(record);
-                // Debug logging for successful calls
+                SettleDataAccessRecord(placeholder, record);
+                // Debug logging for completed calls
                 if (debug) {
-                    console.log(`💾 RunQuery SUCCESS: Query="${queryIdentifier.target}" Rows=${record.rowsReturned}${DescribeDataCap(record)}`);
+                    console.log(record.error
+                        ? `❌ RunQuery FAILED: Query="${queryIdentifier.target}" — ${record.error}`
+                        : `💾 RunQuery SUCCESS: Query="${queryIdentifier.target}" Rows=${record.rowsReturned}${DescribeDataCap(record)}`);
                     if (params.Parameters && Object.keys(params.Parameters).length > 0) {
                         console.log(`   Parameters:`, params.Parameters);
                     }
@@ -2347,7 +2527,7 @@ export class ComponentRunner {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                dataAccess.push({
+                SettleDataAccessRecord(placeholder, {
                     kind: 'RunQuery', target: queryIdentifier.target, identity: queryIdentifier.identity, rowsReturned: 0, capped: false,
                     appliedMaxRows: maxRows.applied, requestedMaxRows: maxRows.requested,
                     durationMs: Date.now() - startedAt, error: errorMessage,
@@ -2368,10 +2548,11 @@ export class ComponentRunner {
         });
         // Expose AI tools
         await page.exposeFunction('__mjExecutePrompt', async (params) => {
+            if (typeof util.ai?.ExecutePrompt !== 'function') {
+                unavailableUtilities.add('utilities.ai.ExecutePrompt');
+                return { success: false, result: 'AI tools are not available in the test harness', modelName: '' };
+            }
             try {
-                if (!util.ai) {
-                    throw new Error('AI tools not available');
-                }
                 // Add contextUser to params if not provided
                 const paramsWithUser = { ...params, contextUser: options.contextUser };
                 const result = await util.ai.ExecutePrompt(paramsWithUser);
@@ -2394,10 +2575,11 @@ export class ComponentRunner {
             }
         });
         await page.exposeFunction('__mjEmbedText', async (params) => {
+            if (typeof util.ai?.EmbedText !== 'function') {
+                unavailableUtilities.add('utilities.ai.EmbedText');
+                throw new Error('AI tools are not available in the test harness');
+            }
             try {
-                if (!util.ai) {
-                    throw new Error('AI tools not available');
-                }
                 // Add contextUser to params if not provided
                 const paramsWithUser = { ...params, contextUser: options.contextUser };
                 const result = await util.ai.EmbedText(paramsWithUser);