@jmruthers/pace-core 0.6.10 → 0.6.11

package/scripts/validate.cjs

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+
+/**
+ * Validation Script for pace-core (monorepo and consuming apps)
+ * @package @jmruthers/pace-core
+ * @module Scripts/validate
+ *
+ * Runs validation in order:
+ * 1. Type check (summary in terminal)
+ * 2. Lint (summary in terminal, full output in audit/<timestamp>-eslint-report.md)
+ * 3. Build (summary in terminal)
+ * 4. Tests (summary in terminal; runs test:coverage when available)
+ * 5. pace-core audit(s): in the pace-core repo, two reports are written to audit/:
+ *    - pace-demo-app-audit-<timestamp>.md (demo app at repo root)
+ *    - pace-core-package-audit-<timestamp>.md (packages/core). In other apps, a single
+ *    audit/<timestamp>-pace-core-audit.md is written.
+ *
+ * Each step runs only if the corresponding script (or audit-tool) exists.
+ *
+ * Usage:
+ *   node node_modules/@jmruthers/pace-core/scripts/validate.cjs
+ *
+ * Or add to package.json:
+ *   "scripts": { "validate": "node node_modules/@jmruthers/pace-core/scripts/validate.cjs" }
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m'
+};
+
+function findPaceCoreRoot() {
+  const cwd = process.cwd();
+  const nodeModulesPath = path.join(cwd, 'node_modules', '@jmruthers', 'pace-core');
+  if (fs.existsSync(nodeModulesPath)) return nodeModulesPath;
+  const scriptDir = __dirname;
+  const relativePath = path.join(scriptDir, '..');
+  if (fs.existsSync(relativePath)) return relativePath;
+  throw new Error('Could not find pace-core package');
+}
+
+function getAvailableScripts() {
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+  if (!fs.existsSync(packageJsonPath)) return {};
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.scripts || {};
+  } catch {
+    return {};
+  }
+}
+
+function generateTimestamp() {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, '0');
+  const d = String(now.getDate()).padStart(2, '0');
+  const h = String(now.getHours()).padStart(2, '0');
+  const min = String(now.getMinutes()).padStart(2, '0');
+  return `${y}${m}${d}${h}${min}`;
+}
+
+function ensureAuditDir() {
+  const auditDir = path.join(process.cwd(), 'audit');
+  if (!fs.existsSync(auditDir)) fs.mkdirSync(auditDir, { recursive: true });
+  return auditDir;
+}
+
+// Convert ESLint output file paths to clickable markdown links (relative to report dir)
+function convertFilePathsToLinks(output, cwd, reportDir) {
+  const lines = output.split('\n');
+  const out = [];
+  let currentFileAbsolute = null;
+  let currentFileDisplayPath = null;
+  let inCommandOutput = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith('>')) {
+      inCommandOutput = true;
+      out.push(line);
+      continue;
+    }
+    if (line.trim() === '' || line.startsWith('eslint') || line.match(/^✖|^✔/)) inCommandOutput = false;
+
+    const filePathMatch = !inCommandOutput && line.match(/^(\/|\.\/)?([^\s]+\.(ts|tsx|js|jsx|mjs|cjs|json|css|scss|sass|less|html|vue|svelte|md|mdx))$/);
+    if (filePathMatch) {
+      const filePath = line.trim();
+      const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      currentFileAbsolute = absolutePath;
+      const displayPath = path.relative(cwd, absolutePath).replace(/\\/g, '/');
+      const linkPath = path.relative(reportDir, absolutePath).replace(/\\/g, '/');
+      currentFileDisplayPath = displayPath;
+      out.push(`[${displayPath}](${linkPath})`);
+    } else {
+      const errorLineMatch = line.match(/^(\s+)(\d+):(\d+)\s+(error|warning)\s+(.+)$/);
+      if (errorLineMatch && currentFileAbsolute) {
+        const [, indent, lineNum, colNum, severity, message] = errorLineMatch;
+        const linkPath = path.relative(reportDir, currentFileAbsolute).replace(/\\/g, '/');
+        const linkUrl = `${linkPath}#L${lineNum}`;
+        out.push(`${indent}[${currentFileDisplayPath}:${lineNum}:${colNum}](${linkUrl})  ${severity}  ${message}`);
+      } else {
+        out.push(line);
+        if (line.trim() === '' && (i === 0 || lines[i - 1].trim() === '')) currentFileAbsolute = currentFileDisplayPath = null;
+        else if (line.startsWith('npm') || line.startsWith('eslint') || line.match(/^✖|^✔/)) currentFileAbsolute = currentFileDisplayPath = null;
+      }
+    }
+  }
+  return out.join('\n');
+}
+
+function buildSteps() {
+  const scripts = getAvailableScripts();
+  const steps = [];
+
+  if (scripts['type-check']) {
+    steps.push({
+      name: 'Type Check',
+      command: 'npm',
+      args: ['run', 'type-check'],
+      parseErrors: (out) => (out.match(/error TS\d+:/g) || []).length,
+      formatErrorCount: (n) => n > 0 ? `${n} error${n !== 1 ? 's' : ''}` : ''
+    });
+  }
+
+  if (scripts.lint) {
+    steps.push({
+      name: 'Lint',
+      command: 'npm',
+      args: ['run', 'lint'],
+      reportFile: (ts) => `audit/${ts}-eslint-report.md`,
+      writeReport: (fullOutput, reportPath, cwd, auditDir) => {
+        const content = `# ESLint Report\n\n**Generated:** ${new Date().toISOString()}\n\n## Output\n\n${convertFilePathsToLinks(fullOutput, cwd, auditDir)}\n`;
+        fs.writeFileSync(reportPath, content, 'utf8');
+      },
+      parseErrors: (out, step) => {
+        const m = out.match(/✖\s+(\d+)\s+problems?\s+\((\d+)\s+errors?,\s+(\d+)\s+warnings?\)/i);
+        if (m) {
+          step.details = { total: parseInt(m[1], 10), errors: parseInt(m[2], 10), warnings: parseInt(m[3], 10) };
+          return step.details.total;
+        }
+        const pm = out.match(/(\d+)\s+problems?/i);
+        if (pm) return parseInt(pm[1], 10);
+        return (out.match(/(?:error|Error:)/gi) || []).length;
+      },
+      formatErrorCount: (n, step) => {
+        if (step.details) return `${step.details.total} problems (${step.details.errors} errors, ${step.details.warnings} warnings)`;
+        return n > 0 ? `${n} problem${n !== 1 ? 's' : ''}` : '';
+      }
+    });
+  }
+
+  if (scripts.build) {
+    steps.push({
+      name: 'Build',
+      command: 'npm',
+      args: ['run', 'build'],
+      parseErrors: (out) => (out.match(/(?:error|Error:)/gi) || []).length,
+      formatErrorCount: (n) => n > 0 ? `${n} error${n !== 1 ? 's' : ''}` : ''
+    });
+  }
+
+  if (scripts.test) {
+    const testScript = scripts['test:coverage'] ? 'test:coverage' : 'test';
+    const testRunsCoverage = testScript === 'test:coverage';
+    steps.push({
+      name: 'Tests',
+      command: 'npm',
+      args: ['run', testScript],
+      testRunsCoverage,
+      parseErrors: (out, step) => {
+        const lines = out.split('\n');
+        let testsLine = null;
+        let testFilesLine = null;
+        for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i].trim();
+          if (/^Tests\s+/.test(line) && (/\d+\s+passed/i.test(line) || /\d+\s+failed/i.test(line))) {
+            testsLine = line;
+            break;
+          }
+          if (!testFilesLine && /^Test\s+Files?\s+/.test(line) && (/\d+\s+passed/i.test(line) || /\d+\s+failed/i.test(line))) {
+            testFilesLine = line;
+          }
+        }
+        const summaryLine = testsLine || testFilesLine;
+        if (summaryLine) {
+          const passedMatch = summaryLine.match(/(\d+)\s+passed/i);
+          const failedMatch = summaryLine.match(/(\d+)\s+failed/i);
+          const skippedMatch = summaryLine.match(/(\d+)\s+skipped/i);
+          const passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
+          const failed = failedMatch ? parseInt(failedMatch[1], 10) : 0;
+          const skipped = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
+          step.details = { passed, failed, skipped };
+          return failed;
+        }
+        const sm = out.match(/Tests?\s+(\d+)\s+failed\s+\|\s+(\d+)\s+passed/i);
+        if (sm) {
+          step.details = { passed: parseInt(sm[2], 10), failed: parseInt(sm[1], 10), skipped: 0 };
+          return parseInt(sm[1], 10);
+        }
+        const allPassedOut = out.match(/Tests?\s+(\d+)\s+passed/i);
+        if (allPassedOut && !out.match(/Tests?\s+\d+\s+failed/i)) {
+          step.details = { passed: parseInt(allPassedOut[1], 10), failed: 0, skipped: 0 };
+          return 0;
+        }
+        const fm = out.match(/Tests?\s+(\d+)\s+failed/i);
+        if (fm) {
+          step.details = { passed: 0, failed: parseInt(fm[1], 10), skipped: 0 };
+          return parseInt(fm[1], 10);
+        }
+        return 0;
+      },
+      formatErrorCount: (n, step) => {
+        if (step.details) {
+          const { passed, failed, skipped } = step.details;
+          const parts = [`${passed} passed`, `${failed} failed`, `${skipped} skipped`];
+          return parts.join(', ');
+        }
+        return n > 0 ? `${n} failed` : '';
+      }
+    });
+  }
+
+  const paceCoreRoot = (() => {
+    try { return findPaceCoreRoot(); } catch { return null; }
+  })();
+  const auditToolPath = paceCoreRoot && path.join(paceCoreRoot, 'audit-tool', 'index.cjs');
+  const cwd = process.cwd();
+  const packagesCorePath = path.resolve(cwd, 'packages', 'core');
+  const isPaceCoreRepo = auditToolPath && fs.existsSync(auditToolPath) && fs.existsSync(packagesCorePath);
+
+  if (auditToolPath && fs.existsSync(auditToolPath)) {
+    if (isPaceCoreRepo) {
+      // In pace-core repo: two audits, both writing to repo audit/ with consistent names.
+      // 1. Demo app (repo root = app that uses src/, package.json at root)
+      steps.push({
+        name: 'pace-core Demo App Audit',
+        command: 'node',
+        args: [auditToolPath, '.', '--output', path.join('audit', 'pace-demo-app-audit.md')],
+        runInCwd: true,
+        parseErrors: (out) => {
+          const m = out.match(/\*\*Total Issues:\*\*\s+(\d+)/i);
+          return m ? parseInt(m[1], 10) : 0;
+        },
+        formatErrorCount: (n) => n > 0 ? `${n} issue${n !== 1 ? 's' : ''}` : ''
+      });
+      // 2. packages/core (pace-core package code)
+      steps.push({
+        name: 'pace-core Package Audit',
+        command: 'node',
+        args: [auditToolPath, packagesCorePath, '--output', path.join('..', '..', 'audit', 'pace-core-package-audit.md')],
+        runInCwd: true,
+        parseErrors: (out) => {
+          const m = out.match(/\*\*Total Issues:\*\*\s+(\d+)/i);
+          return m ? parseInt(m[1], 10) : 0;
+        },
+        formatErrorCount: (n) => n > 0 ? `${n} issue${n !== 1 ? 's' : ''}` : ''
+      });
+    } else {
+      // Consuming app: single audit on current directory
+      steps.push({
+        name: 'pace-core Audit',
+        command: 'node',
+        args: [auditToolPath],
+        runInCwd: true,
+        parseErrors: (out) => {
+          const m = out.match(/\*\*Total Issues:\*\*\s+(\d+)/i);
+          return m ? parseInt(m[1], 10) : 0;
+        },
+        formatErrorCount: (n) => n > 0 ? `${n} issue${n !== 1 ? 's' : ''}` : ''
+      });
+    }
+  }
+
+  return steps;
+}
+
+function runStep(step, runTimestamp, auditDir) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    let stdout = '';
+    let stderr = '';
+    let timeoutId = null;
+    let testKillTimeout = null;
+    let testSummarySeen = false;
+    const timeout = step.name === 'Tests' ? 300000 : 120000;
+    const cwd = process.cwd();
+    const spawnOpts = {
+      cwd: step.runInCwd ? cwd : cwd,
+      shell: !step.runInCwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, CI: 'true', FORCE_COLOR: '0' }
+    };
+    const child = spawn(
+      step.command,
+      step.args,
+      spawnOpts
+    );
+
+    const checkForTestSummary = () => {
+      if (step.name === 'Tests' && !step.testRunsCoverage && !testSummarySeen) {
+        const output = stdout + stderr;
+        if ((/Tests?\s+\d+\s+failed\s+\|\s+\d+\s+passed/i.test(output) || /Test\s+Files?\s+\d+\s+failed\s+\|\s+\d+\s+passed/i.test(output)) &&
+            (/Duration|Start at|Watching for file changes/i.test(output))) {
+          if (testKillTimeout) clearTimeout(testKillTimeout);
+          testKillTimeout = setTimeout(() => {
+            testSummarySeen = true;
+            child.kill('SIGTERM');
+          }, 1000);
+        }
+      }
+    };
+
+    child.stdout.on('data', (d) => { stdout += d.toString(); checkForTestSummary(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); checkForTestSummary(); });
+
+    timeoutId = setTimeout(() => {
+      if (testKillTimeout) clearTimeout(testKillTimeout);
+      child.kill('SIGTERM');
+      resolve({
+        name: step.name,
+        passed: false,
+        exitCode: -1,
+        errorCount: 1,
+        duration: ((Date.now() - startTime) / 1000).toFixed(2),
+        fullOutput: stdout + stderr,
+        output: `Command timed out after ${timeout / 1000}s`,
+        step
+      });
+    }, timeout);
+
+    child.on('close', (code) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (testKillTimeout) clearTimeout(testKillTimeout);
+      const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+      const fullOutput = stdout + stderr;
+      let errorCount = step.parseErrors ? step.parseErrors(fullOutput, step) : 0;
+      const isAuditStep = step.name === 'pace-core Audit' || step.name === 'pace-core Demo App Audit' || step.name === 'pace-core Package Audit';
+      if (step.name === 'Tests' && code !== 0 && errorCount === 0) {
+        errorCount = 1;
+        if (!step.details) step.details = { passed: 0, failed: 1, skipped: 0 };
+      }
+      const passed = step.name === 'Tests'
+        ? (code === 0 && errorCount === 0)
+        : isAuditStep
+          ? code === 0 && errorCount === 0
+          : code === 0 && errorCount === 0;
+      resolve({
+        name: step.name,
+        passed,
+        exitCode: code,
+        errorCount,
+        duration,
+        fullOutput,
+        output: fullOutput.slice(0, 500),
+        step
+      });
+    });
+
+    child.on('error', (err) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (testKillTimeout) clearTimeout(testKillTimeout);
+      resolve({
+        name: step.name,
+        passed: false,
+        exitCode: -1,
+        errorCount: 1,
+        duration: ((Date.now() - startTime) / 1000).toFixed(2),
+        fullOutput: '',
+        output: err.message,
+        step
+      });
+    });
+  });
+}
+
+async function main() {
+  const steps = buildSteps();
+  if (steps.length === 0) {
+    console.log(`${colors.yellow}No validation steps available.${colors.reset}`);
+    const scripts = getAvailableScripts();
+    ['type-check', 'lint', 'build', 'test'].forEach(s => {
+      if (scripts[s]) console.log(`  • ${s}`);
+    });
+    console.log(`${colors.cyan}Add scripts to package.json and ensure pace-core (with audit-tool) is available.${colors.reset}`);
+    process.exit(0);
+  }
+
+  const runTimestamp = generateTimestamp();
+  const auditDir = ensureAuditDir();
+  const cwd = process.cwd();
+
+  console.log(`${colors.bold}${colors.cyan}🔍 Running validation...${colors.reset}\n`);
+  console.log('='.repeat(60));
+
+  const results = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    console.log(`\n[${i + 1}/${steps.length}] Running: ${step.name}`);
+    console.log('-'.repeat(60));
+
+    const result = await runStep(step, runTimestamp, auditDir);
+    results.push(result);
+
+    if (step.reportFile && result.fullOutput !== undefined) {
+      const reportPath = path.join(cwd, step.reportFile(runTimestamp));
+      try {
+        step.writeReport(result.fullOutput, reportPath, cwd, auditDir);
+        console.log(`Report: ${reportPath}`);
+      } catch (e) {
+        console.log(`${colors.yellow}Could not write report: ${e.message}${colors.reset}`);
+      }
+    }
+    if ((step.name === 'pace-core Audit' || step.name === 'pace-core Demo App Audit' || step.name === 'pace-core Package Audit') && result.fullOutput) {
+      const reportSavedMatch = result.fullOutput.match(/Report saved to:[^\n]+/);
+      if (reportSavedMatch) console.log(reportSavedMatch[0].trim());
+    }
+
+    const status = result.passed ? `${colors.green}✅ PASSED${colors.reset}` : `${colors.red}❌ FAILED${colors.reset}`;
+    const errorInfo = result.errorCount > 0 && result.step.formatErrorCount
+      ? result.step.formatErrorCount(result.errorCount, result.step)
+      : '';
+    const testSummary = step.name === 'Tests' && result.step.details && result.step.formatErrorCount
+      ? result.step.formatErrorCount(result.errorCount, result.step)
+      : '';
+    console.log(`Status: ${status}${errorInfo ? ' ' + errorInfo : ''}`);
+    if (testSummary) console.log(`Tests: ${testSummary}`);
+    if (step.name === 'Tests' && !step.testRunsCoverage) {
+      console.log(`${colors.cyan}Tip: add a \`test:coverage\` script to package.json to generate a coverage report during validate.${colors.reset}`);
+    }
+    if (step.name === 'Tests' && step.testRunsCoverage) {
+      const coverageIndex = path.join(cwd, 'coverage', 'index.html');
+      if (fs.existsSync(coverageIndex)) {
+        console.log(`Coverage report: file://${coverageIndex}`);
+      } else {
+        console.log(`${colors.yellow}Coverage report not found at ${coverageIndex} (tests may have failed before report was written).${colors.reset}`);
+      }
+    }
+    console.log(`Duration: ${result.duration}s`);
+    console.log(`Exit Code: ${result.exitCode}`);
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log(`\n${colors.bold}📊 VALIDATION SUMMARY${colors.reset}\n`);
+  console.log('='.repeat(60));
+
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+  results.forEach((r) => {
+    const status = r.passed ? `${colors.green}✅${colors.reset}` : `${colors.red}❌${colors.reset}`;
+    const err = r.errorCount > 0 && r.step.formatErrorCount ? ` - ${r.step.formatErrorCount(r.errorCount, r.step)}` : '';
+    console.log(`${status} ${r.name}${err}`);
+  });
+
+  console.log('\n' + '-'.repeat(60));
+  console.log(`Total: ${results.length} checks`);
+  console.log(`${colors.green}Passed: ${passed}${colors.reset}`);
+  console.log(`${failed > 0 ? colors.red : colors.green}Failed: ${failed}${colors.reset}`);
+  console.log('='.repeat(60));
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`${colors.red}❌ Validation error:${colors.reset}`, err);
+    process.exit(1);
+  });
+}
+
+module.exports = { main };

package/src/__tests__/helpers/{__tests__/component-test-utils.test.tsx → component-test-utils.test.tsx}

@@ -1,7 +1,7 @@
 /**
  * @file Component Test Utilities Tests
  * @package @jmruthers/pace-core
- * @module TestHelpers/__tests__
+ * @module TestHelpers
  * @since 1.0.0
  */
 
@@ -13,10 +13,10 @@ import {
   componentTestPatterns,
   commonScenarios,
   createTestData
-} from '../component-test-utils';
+} from './component-test-utils';
 
 // Mock the renderWithProviders function
-vi.mock('../test-utils', () => ({
+vi.mock('./test-utils', () => ({
   renderWithProviders: vi.fn((ui) => render(ui))
 }));
 

package/src/__tests__/helpers/{__tests__/optimized-test-setup.test.ts → optimized-test-setup.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Optimized Test Setup Tests
  * @package @jmruthers/pace-core
- * @module TestHelpers/__tests__
+ * @module TestHelpers
  * @since 1.0.0
  */
 
@@ -12,7 +12,7 @@ import {
   setupOptimizedMocks,
   cleanupOptimizedMocks,
   createOptimizedTest
-} from '../optimized-test-setup';
+} from './optimized-test-setup';
 
 describe('[helpers] createFastMock', () => {
     it('creates mock that resolves with value', async () => {

package/src/__tests__/helpers/{__tests__/supabaseMock.test.ts → supabaseMock.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Supabase Mock Utilities Tests
  * @package @jmruthers/pace-core
- * @module TestHelpers/__tests__
+ * @module TestHelpers
  * @since 1.0.0
  */
 
@@ -11,7 +11,7 @@ import {
   createMockSupabaseClient,
   createMockQueryBuilderWithData,
   createMockQueryBuilderWithError
-} from '../supabaseMock';
+} from './supabaseMock';
 
 describe('[helpers] createMockQueryBuilder', () => {
     it('creates query builder with default data', async () => {

package/src/__tests__/helpers/{__tests__/test-providers.test.tsx → test-providers.test.tsx}

@@ -8,7 +8,7 @@
  */
 
 import { render, screen } from '@testing-library/react';
-import { TestProviderWrapper, renderWithProviders, createMockUseUnifiedAuth, useUnifiedAuth } from '../test-providers';
+import { TestProviderWrapper, renderWithProviders, createMockUseUnifiedAuth, useUnifiedAuth } from './test-providers';
 
 // Test component that uses the hook
 function TestComponent() {

package/src/__tests__/helpers/test-providers.tsx

@@ -20,13 +20,13 @@ interface MockUnifiedAuthContextType {
   isLoading: boolean;
   error: any | null;
 
-  // Auth methods
-  signIn: (email: string, password?: string) => Promise<{ error: any | null }>;
-  signUp: (email: string, password: string) => Promise<{ error: any | null }>;
-  signOut: () => Promise<{ error: any | null }>;
-  resetPassword: (email: string) => Promise<{ error: any | null }>;
-  updatePassword: (password: string) => Promise<{ error: any | null }>;
-  refreshSession: () => Promise<{ error: any | null }>;
+  // Auth methods (ApiResult shape)
+  signIn: (email: string, password?: string) => Promise<{ ok: true; data: { user: any; session: any } } | { ok: false; error: { code: string; message: string } }>;
+  signUp: (email: string, password: string) => Promise<{ ok: true; data: { user: any; session: any } } | { ok: false; error: { code: string; message: string } }>;
+  signOut: () => Promise<{ ok: true; data: { user: any; session: any } } | { ok: false; error: { code: string; message: string } }>;
+  resetPassword: (email: string) => Promise<{ ok: true; data: { user: any; session: any } } | { ok: false; error: { code: string; message: string } }>;
+  updatePassword: (password: string) => Promise<{ ok: true; data: { user: any; session: any } } | { ok: false; error: { code: string; message: string } }>;
+  refreshSession: () => Promise<{ ok: true; data: { user: any; session: any } } | { ok: false; error: { code: string; message: string } }>;
 
   // Note: RBAC properties removed - users should use useRBAC() hook instead
   // RBAC functionality is no longer part of UnifiedAuthProvider
@@ -81,45 +81,43 @@ interface MockUnifiedAuthContextType {
 // Mock Supabase client for tests
 const mockSupabaseClient = createMockSupabaseClient();
 
+const mockUser = {
+  id: 'test-user-id',
+  email: 'test@example.com',
+  user_metadata: {},
+  app_metadata: {},
+  aud: 'authenticated',
+  created_at: '2023-01-01T00:00:00Z',
+  updated_at: '2023-01-01T00:00:00Z'
+};
+const mockSession = {
+  access_token: 'test-access-token',
+  refresh_token: 'test-refresh-token',
+  expires_in: 3600,
+  expires_at: Date.now() + 3600000,
+  token_type: 'bearer',
+  user: mockUser
+};
+
+const okAuthResult = { ok: true as const, data: { user: mockUser, session: mockSession } };
+const okSignedOutResult = { ok: true as const, data: { user: null, session: null } };
+
 // Default mock auth state
 const defaultMockAuth: MockUnifiedAuthContextType = {
   // Auth state
-  user: {
-    id: 'test-user-id',
-    email: 'test@example.com',
-    user_metadata: {},
-    app_metadata: {},
-    aud: 'authenticated',
-    created_at: '2023-01-01T00:00:00Z',
-    updated_at: '2023-01-01T00:00:00Z'
-  },
-  session: {
-    access_token: 'test-access-token',
-    refresh_token: 'test-refresh-token',
-    expires_in: 3600,
-    expires_at: Date.now() + 3600000,
-    token_type: 'bearer',
-    user: {
-      id: 'test-user-id',
-      email: 'test@example.com',
-      user_metadata: {},
-      app_metadata: {},
-      aud: 'authenticated',
-      created_at: '2023-01-01T00:00:00Z',
-      updated_at: '2023-01-01T00:00:00Z'
-    }
-  },
+  user: mockUser,
+  session: mockSession,
   isAuthenticated: true,
   isLoading: false,
   error: null,
 
-  // Auth methods
-  signIn: vi.fn(() => Promise.resolve({ error: null })),
-  signOut: vi.fn(() => Promise.resolve({ error: null })),
-  signUp: vi.fn(() => Promise.resolve({ error: null })),
-  resetPassword: vi.fn(() => Promise.resolve({ error: null })),
-  updatePassword: vi.fn(() => Promise.resolve({ error: null })),
-  refreshSession: vi.fn(() => Promise.resolve({ error: null })),
+  // Auth methods (ApiResult shape)
+  signIn: vi.fn(() => Promise.resolve(okAuthResult)),
+  signOut: vi.fn(() => Promise.resolve(okSignedOutResult)),
+  signUp: vi.fn(() => Promise.resolve(okAuthResult)),
+  resetPassword: vi.fn(() => Promise.resolve(okAuthResult)),
+  updatePassword: vi.fn(() => Promise.resolve(okAuthResult)),
+  refreshSession: vi.fn(() => Promise.resolve(okAuthResult)),
 
   // RBAC properties removed - use useRBAC() hook instead
 

package/src/__tests__/helpers/{__tests__/test-utils.test.tsx → test-utils.test.tsx}

@@ -1,7 +1,7 @@
 /**
  * @file Test Utilities Tests
  * @package @jmruthers/pace-core
- * @module TestHelpers/__tests__
+ * @module TestHelpers
  * @since 1.0.0
  */
 
@@ -19,7 +19,7 @@ import {
   setupTest,
   createComponentTestStructure,
   createHookTestStructure
-} from '../test-utils';
+} from './test-utils';
 
 // Mock the fixtures
 vi.mock('../fixtures/test-data', () => ({
@@ -28,7 +28,8 @@ vi.mock('../fixtures/test-data', () => ({
       basic: {
         id: 'test-user-id',
         email: 'test@example.com',
-        name: 'Test User'
+        name: 'Test User',
+        created_at: '2023-01-01T00:00:00Z',
       }
     },
     mockFunctions: {