@open-mercato/shared 0.6.6-develop.6460.1.f94c74174c → 0.6.6-develop.6471.1.9ab5bdd79a

package/src/lib/logger/transport.pretty.ts

@@ -0,0 +1,94 @@
+import type { LogBindings, Logger } from './index'
+import { parseBooleanToken } from '../boolean'
+import { isLevelEnabled, type LogLevel } from './level'
+import { formatBindings } from './transport.console'
+import { OM_LOG_DESTINATION_ENV, isStderrDestinationToken } from './transport.server'
+
+export const OM_LOG_PRETTY_ENV = 'OM_LOG_PRETTY'
+
+type EnvSource = Record<string, string | undefined>
+
+function readProcessEnv(): EnvSource {
+  return typeof process === 'undefined' ? {} : process.env
+}
+
+/** Resolve pretty mode from `OM_LOG_PRETTY`, defaulting to on outside production. */
+export function resolvePrettyMode(env: EnvSource = readProcessEnv()): boolean {
+  const parsed = parseBooleanToken(env[OM_LOG_PRETTY_ENV])
+  if (parsed !== null) return parsed
+  return env.NODE_ENV !== 'production'
+}
+
+let cachedPrettyMode: boolean | null = null
+
+export function isPrettyModeEnabled(): boolean {
+  if (cachedPrettyMode === null) cachedPrettyMode = resolvePrettyMode()
+  return cachedPrettyMode
+}
+
+/** Internal: clear the memoized pretty mode so tests can vary `OM_LOG_PRETTY`. */
+export function resetLogPrettyCache(): void {
+  cachedPrettyMode = null
+}
+
+const LEVEL_LABELS: Record<LogLevel, string> = {
+  debug: 'DEBUG',
+  info: 'INFO ',
+  warn: 'WARN ',
+  error: 'ERROR',
+}
+
+const ANSI_RESET = '\x1b[0m'
+const ANSI_DIM = '\x1b[2m'
+
+const LEVEL_COLORS: Record<LogLevel, string> = {
+  debug: ANSI_DIM,
+  info: '\x1b[36m',
+  warn: '\x1b[33m',
+  error: '\x1b[31m',
+}
+
+type WritableLogStream = { write(chunk: string): unknown; isTTY?: boolean }
+
+function resolveStream(): WritableLogStream {
+  const useStderr = isStderrDestinationToken(readProcessEnv()[OM_LOG_DESTINATION_ENV])
+  return useStderr ? process.stderr : process.stdout
+}
+
+function formatTimestamp(date: Date): string {
+  const hours = String(date.getHours()).padStart(2, '0')
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+  const seconds = String(date.getSeconds()).padStart(2, '0')
+  const millis = String(date.getMilliseconds()).padStart(3, '0')
+  return `${hours}:${minutes}:${seconds}.${millis}`
+}
+
+export function createPrettyLogger(namespace: string, bindings: LogBindings = {}): Logger {
+  const emit = (level: LogLevel, msg: string, fields?: LogBindings): void => {
+    if (!isLevelEnabled(level)) return
+    const stream = resolveStream()
+    const { err, ...rest } = { ...bindings, ...fields }
+    let scope = namespace
+    if (typeof rest.component === 'string' && rest.component) {
+      scope = `${namespace}:${rest.component}`
+      delete rest.component
+    }
+    const tail = formatBindings(err instanceof Error || err === undefined ? rest : { ...rest, err })
+    const colored = stream.isTTY === true
+    const timestamp = formatTimestamp(new Date())
+    const timestampPart = colored ? `${ANSI_DIM}${timestamp}${ANSI_RESET}` : timestamp
+    const label = LEVEL_LABELS[level]
+    const levelPart = colored ? `${LEVEL_COLORS[level]}${label}${ANSI_RESET}` : label
+    let line = `${timestampPart} ${levelPart} [${scope}] ${msg}`
+    if (tail) line += ` ${tail}`
+    if (err instanceof Error) line += `\n${err.stack ?? err.message}`
+    stream.write(`${line}\n`)
+  }
+  return {
+    debug: (msg, fields) => emit('debug', msg, fields),
+    info: (msg, fields) => emit('info', msg, fields),
+    warn: (msg, fields) => emit('warn', msg, fields),
+    error: (msg, fields) => emit('error', msg, fields),
+    child: (childBindings) => createPrettyLogger(namespace, { ...bindings, ...childBindings }),
+  }
+}

package/src/lib/logger/transport.server.ts

@@ -0,0 +1,125 @@
+import type { LogBindings, Logger } from './index'
+import { getLogLevel } from './level'
+import { createConsoleLogger } from './transport.console'
+
+const REDACT_PATHS = [
+  'password',
+  '*.password',
+  'token',
+  '*.token',
+  'secret',
+  '*.secret',
+  'authorization',
+  '*.authorization',
+  'headers.authorization',
+  'req.headers.authorization',
+]
+
+const REDACT_CENSOR = '[Redacted]'
+
+export const OM_LOG_DESTINATION_ENV = 'OM_LOG_DESTINATION'
+
+type PinoBaseLogger = {
+  debug(fields: Record<string, unknown>, msg: string): void
+  info(fields: Record<string, unknown>, msg: string): void
+  warn(fields: Record<string, unknown>, msg: string): void
+  error(fields: Record<string, unknown>, msg: string): void
+  child(bindings: Record<string, unknown>): PinoBaseLogger
+}
+
+type PinoFactory = (options: Record<string, unknown>, destination?: unknown) => PinoBaseLogger
+
+type NodeModuleBuiltin = {
+  createRequire(basePath: string): (id: string) => unknown
+}
+
+type ProcessWithBuiltins = {
+  cwd(): string
+  getBuiltinModule?(id: string): unknown
+  env?: Record<string, string | undefined>
+  stderr?: unknown
+}
+
+export function isStderrDestinationToken(raw: string | undefined): boolean {
+  return typeof raw === 'string' && raw.trim().toLowerCase() === 'stderr'
+}
+
+function resolveDestinationStream(nodeProcess: ProcessWithBuiltins): unknown {
+  return isStderrDestinationToken(nodeProcess.env?.[OM_LOG_DESTINATION_ENV])
+    ? nodeProcess.stderr
+    : undefined
+}
+
+let cachedRoot: PinoBaseLogger | null | undefined
+let rootGeneration = 0
+
+/**
+ * pino is loaded lazily via a runtime `require` obtained from
+ * `process.getBuiltinModule('node:module')` — never through a static import —
+ * so browser/edge bundles that reach this file never resolve pino or
+ * `node:module`. Any load failure falls back to the console transport.
+ */
+function loadPinoRoot(): PinoBaseLogger | null {
+  if (cachedRoot !== undefined) return cachedRoot
+  try {
+    const nodeProcess = (typeof process === 'undefined' ? undefined : process) as
+      | ProcessWithBuiltins
+      | undefined
+    const moduleBuiltin = nodeProcess?.getBuiltinModule?.('node:module') as
+      | NodeModuleBuiltin
+      | undefined
+    if (!nodeProcess || !moduleBuiltin) {
+      cachedRoot = null
+      return cachedRoot
+    }
+    const requireFromApp = moduleBuiltin.createRequire(`${nodeProcess.cwd()}/package.json`)
+    const pinoExport = requireFromApp('pino') as PinoFactory | { default: PinoFactory }
+    const pinoFactory = typeof pinoExport === 'function' ? pinoExport : pinoExport.default
+    const destination = resolveDestinationStream(nodeProcess)
+    const options = {
+      level: getLogLevel(),
+      redact: { paths: REDACT_PATHS, censor: REDACT_CENSOR },
+    }
+    cachedRoot = destination ? pinoFactory(options, destination) : pinoFactory(options)
+  } catch {
+    cachedRoot = null
+  }
+  return cachedRoot
+}
+
+function wrapPinoLogger(pinoLogger: PinoBaseLogger): Logger {
+  return {
+    debug: (msg, fields) => pinoLogger.debug(fields ?? {}, msg),
+    info: (msg, fields) => pinoLogger.info(fields ?? {}, msg),
+    warn: (msg, fields) => pinoLogger.warn(fields ?? {}, msg),
+    error: (msg, fields) => pinoLogger.error(fields ?? {}, msg),
+    child: (childBindings) => wrapPinoLogger(pinoLogger.child(childBindings)),
+  }
+}
+
+export function createServerLogger(namespace: string, bindings: LogBindings = {}): Logger {
+  let delegate: Logger | null = null
+  let delegateGeneration = -1
+  const resolveDelegate = (): Logger => {
+    if (delegate && delegateGeneration === rootGeneration) return delegate
+    delegateGeneration = rootGeneration
+    const root = loadPinoRoot()
+    delegate = root
+      ? wrapPinoLogger(root.child({ name: namespace, ...bindings }))
+      : createConsoleLogger(namespace, bindings)
+    return delegate
+  }
+  return {
+    debug: (msg, fields) => resolveDelegate().debug(msg, fields),
+    info: (msg, fields) => resolveDelegate().info(msg, fields),
+    warn: (msg, fields) => resolveDelegate().warn(msg, fields),
+    error: (msg, fields) => resolveDelegate().error(msg, fields),
+    child: (childBindings) => createServerLogger(namespace, { ...bindings, ...childBindings }),
+  }
+}
+
+/** Internal: clear the cached pino root so tests can re-run transport selection. */
+export function resetServerLoggerCache(): void {
+  cachedRoot = undefined
+  rootGeneration += 1
+}

package/src/lib/logger/transport.ts

@@ -0,0 +1,17 @@
+import type { Logger } from './index'
+import { createConsoleLogger } from './transport.console'
+import { createPrettyLogger, isPrettyModeEnabled } from './transport.pretty'
+import { createServerLogger } from './transport.server'
+
+function isNodeServerRuntime(): boolean {
+  if (typeof window !== 'undefined') return false
+  if (typeof process === 'undefined') return false
+  if (process.env.NEXT_RUNTIME === 'edge') return false
+  return true
+}
+
+/** Pick the runtime-appropriate transport: pretty or pino on the Node server, console elsewhere. */
+export function selectTransport(namespace: string): Logger {
+  if (!isNodeServerRuntime()) return createConsoleLogger(namespace)
+  return isPrettyModeEnabled() ? createPrettyLogger(namespace) : createServerLogger(namespace)
+}

package/src/lib/middleware/page-executor.ts

@@ -7,6 +7,9 @@ import type {
 } from '@open-mercato/shared/modules/middleware/page'
 import { CONTINUE_PAGE_MIDDLEWARE, matchPageMiddlewareTarget } from '@open-mercato/shared/modules/middleware/page'
 import { applyPageGuardOverridesToEntries } from '@open-mercato/shared/modules/overrides'
+import { createLogger } from '../logger'
+
+const logger = createLogger('shared').child({ component: 'middleware' })
 
 type ExecutePageMiddlewareArgs = {
   entries: PageMiddlewareRegistryEntry[]
@@ -49,7 +52,7 @@ export async function executePageMiddleware(args: ExecutePageMiddlewareArgs): Pr
       if (onError) {
         onError(error, { id: middleware.id, priority: middleware.priority })
       } else {
-        console.error('[middleware:page] execution failed', { id: middleware.id, error })
+        logger.error('Page middleware execution failed', { id: middleware.id, err: error })
       }
       throw error
     }

package/src/lib/modules/__tests__/registry.test.ts

@@ -1,4 +1,19 @@
 import type { Module } from '@open-mercato/shared/modules/registry'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+jest.mock('@open-mercato/shared/lib/logger', () => {
+  const mocked = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: jest.fn(),
+  }
+  mocked.child.mockImplementation(() => mocked)
+  return { createLogger: jest.fn(() => mocked) }
+})
+const loggerDebug = createLogger('shared').debug as jest.Mock
+
 
 const GLOBAL_KEY = '__openMercatoModulesRegistry__'
 
@@ -85,31 +100,23 @@ describe('shared modules registry', () => {
 
   it('emits the HMR debug log on re-registration in development', () => {
     process.env.NODE_ENV = 'development'
-    const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {})
-    try {
-      const registry = loadRegistry()
-      registry.registerModules(sampleModules)
-      expect(debugSpy).not.toHaveBeenCalled()
-      registry.registerModules(sampleModules)
-      expect(debugSpy).toHaveBeenCalledWith(
-        '[Bootstrap] Modules re-registered (this may occur during HMR)',
-      )
-    } finally {
-      debugSpy.mockRestore()
-    }
+    loggerDebug.mockClear()
+    const registry = loadRegistry()
+    registry.registerModules(sampleModules)
+    expect(loggerDebug).not.toHaveBeenCalled()
+    registry.registerModules(sampleModules)
+    expect(loggerDebug).toHaveBeenCalledWith(
+      'Modules re-registered (this may occur during HMR)',
+    )
   })
 
   it('does not emit the HMR debug log when NODE_ENV is not development', () => {
     process.env.NODE_ENV = 'production'
-    const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {})
-    try {
-      const registry = loadRegistry()
-      registry.registerModules(sampleModules)
-      registry.registerModules(sampleModules)
-      expect(debugSpy).not.toHaveBeenCalled()
-    } finally {
-      debugSpy.mockRestore()
-    }
+    loggerDebug.mockClear()
+    const registry = loadRegistry()
+    registry.registerModules(sampleModules)
+    registry.registerModules(sampleModules)
+    expect(loggerDebug).not.toHaveBeenCalled()
   })
 
   it('does not let i18n-only registrations clobber runtime module contracts', () => {

package/src/lib/modules/registry.ts

@@ -1,6 +1,9 @@
 import type { Module } from '@open-mercato/shared/modules/registry'
 import { applyModuleOverridesToModules } from '@open-mercato/shared/modules/overrides'
 import { invalidateDictionaryCache } from '../i18n/dictionary-cache'
+import { createLogger } from '../logger'
+
+const logger = createLogger('shared').child({ component: 'modules-registry' })
 
 // Registration pattern for publishable packages.
 // Use globalThis to survive tsx/esbuild module duplication where the same
@@ -49,7 +52,7 @@ function mergeI18nModules(existing: Module[], incoming: Module[]): Module[] {
 export function registerModules(modules: Module[]) {
   const existing = getGlobalModules()
   if (existing !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] Modules re-registered (this may occur during HMR)')
+    logger.debug('Modules re-registered (this may occur during HMR)')
   }
   const nextModules = applyModuleOverridesToModules(modules)
   const shouldMergeI18nOnly = existing !== null

package/src/lib/profiler/index.ts

@@ -1,4 +1,7 @@
 import { parseBooleanToken } from '../boolean'
+import { createLogger } from '../logger'
+
+const logger = createLogger('shared').child({ component: 'profiler' })
 
 const ROUND_PRECISION = 1000
 const NS_PER_MS = BigInt(1_000_000)
@@ -267,9 +270,8 @@ class ProfilerImpl implements Profiler {
     if (this.root.meta && Object.keys(this.root.meta).length > 0) {
       snapshot.meta = this.root.meta
     }
-    const serialized = JSON.stringify(snapshot, null, 2)
     try {
-      console.info(this.root.loggerLabel, serialized)
+      logger.info('Profiler snapshot', { label: this.root.loggerLabel, snapshot })
     } catch {
       // ignore logging failures
     }

package/src/lib/query/__tests__/query-extension-runner.test.ts

@@ -14,6 +14,22 @@ import {
   runAfterQueryPipeline,
 } from '../query-extension-runner'
 import type { SyncQueryEventPayload } from '../sync-query-event-types'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+jest.mock('@open-mercato/shared/lib/logger', () => {
+  const mocked = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: jest.fn(),
+  }
+  mocked.child.mockImplementation(() => mocked)
+  return { createLogger: jest.fn(() => mocked) }
+})
+const loggerError = createLogger('shared').error as jest.Mock
+const loggerWarn = createLogger('shared').warn as jest.Mock
+
 
 const ctx = { resolve: jest.fn() }
 
@@ -204,7 +220,7 @@ describe('runBeforeQueryEvent', () => {
   })
 
   it('catches thrown errors and returns blocked', async () => {
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
+    loggerError.mockClear()
     registerSyncSubscribers([
       makeQuerySub(
         'customers.person.querying',
@@ -217,7 +233,6 @@ describe('runBeforeQueryEvent', () => {
     const result = await runBeforeQueryEvent(payload, ctx)
     expect(result.ok).toBe(false)
     expect(result.errorStatus).toBe(500)
-    consoleSpy.mockRestore()
   })
 })
 
@@ -266,7 +281,7 @@ describe('runAfterQueryEvent', () => {
   })
 
   it('rejects invalid modifiedResult shape', async () => {
-    const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+    loggerWarn.mockClear()
     registerSyncSubscribers([
       makeQuerySub(
         'customers.person.queried',
@@ -278,14 +293,14 @@ describe('runAfterQueryEvent', () => {
     const payload = makeQueriedPayload()
     const result = await runAfterQueryEvent(payload, ctx)
     expect(result.modifiedResult).toBeUndefined()
-    expect(consoleSpy).toHaveBeenCalledWith(
+    expect(loggerWarn).toHaveBeenCalledWith(
       expect.stringContaining('invalid modifiedResult shape'),
+      expect.objectContaining({ subscriberId: expect.any(String) }),
     )
-    consoleSpy.mockRestore()
   })
 
   it('continues on subscriber error', async () => {
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
+    loggerError.mockClear()
     const handler2 = jest.fn().mockResolvedValue({
       modifiedResult: {
         items: [{ id: '1', transformed: true }],
@@ -307,7 +322,6 @@ describe('runAfterQueryEvent', () => {
     const result = await runAfterQueryEvent(payload, ctx)
     expect(handler2).toHaveBeenCalled()
     expect(result.modifiedResult).toBeDefined()
-    consoleSpy.mockRestore()
   })
 })
 

package/src/lib/query/engine.ts

@@ -22,6 +22,9 @@ import {
 } from '../crud/custom-field-definition-index'
 import { resolveEncryptedSortFields, resolveEncryptedSortMaxRows, sortRowsInMemory } from './encrypted-sort'
 import { mapWithConcurrency } from './bounded-decrypt'
+import { createLogger } from '../logger'
+
+const logger = createLogger('shared').child({ component: 'query' })
 
 const DECRYPT_CONCURRENCY = 8
 
@@ -138,11 +141,7 @@ export function resolveEntityTableName(em: EntityManager | undefined, entity: En
   }
 
   const fallback = pluralizeBaseName(rawName || '')
-  console.warn(
-    `[QueryEngine] Could not resolve entity "${entity}" via ORM metadata. ` +
-    `Falling back to table name "${fallback}". ` +
-    `Ensure the entity ID segment matches the class name convention.`
-  )
+  logger.warn('Could not resolve entity via ORM metadata; falling back to table name — ensure the entity ID segment matches the class name convention', { entity, fallback })
   entityTableCache.set(entity, fallback)
   return fallback
 }
@@ -945,7 +944,7 @@ export class BasicQueryEngine implements QueryEngine {
         )
         return { ...item, ...decrypted }
       } catch (err) {
-        console.error('QueryEngine: error decrypting entity payload', err)
+        logger.error('Error decrypting entity payload', { err })
         return item
       }
     }
@@ -1409,10 +1408,8 @@ export class BasicQueryEngine implements QueryEngine {
 
   private logSearchDebug(event: string, payload: Record<string, unknown>) {
     try {
-      console.info('[query:search]', event, JSON.stringify(payload))
-    } catch {
-      console.info('[query:search]', event, payload)
-    }
+      logger.debug(event, payload)
+    } catch {}
   }
 
   private resolveOrganizationScope(opts: QueryOptions): { ids: string[]; includeNull: boolean } | null {

package/src/lib/query/query-extension-runner.ts

@@ -18,6 +18,9 @@ import { getEnrichersForEntity } from '../crud/enricher-registry'
 import { applyResponseEnrichers, applyResponseEnricherToRecord } from '../crud/enricher-runner'
 import type { SyncQueryEventPayload, SyncQueryEventResult } from './sync-query-event-types'
 import type { QueryOptions, QueryResult } from './types'
+import { createLogger } from '../logger'
+
+const logger = createLogger('shared').child({ component: 'query-extensions' })
 
 // ---------------------------------------------------------------------------
 // Entity-to-event-ID helpers
@@ -96,10 +99,7 @@ export async function runBeforeQueryEvent(
         currentQuery = { ...currentQuery, ...queryResult.modifiedQuery }
       }
     } catch (error) {
-      console.error(
-        `[query-extension] before-query subscriber failed: ${subscriber.metadata.id}`,
-        error,
-      )
+      logger.error('Before-query subscriber failed', { subscriberId: subscriber.metadata.id, err: error })
       return {
         ok: false,
         errorMessage: `Subscriber ${subscriber.metadata.id} threw unexpectedly`,
@@ -148,16 +148,11 @@ export async function runAfterQueryEvent(
         if (isValidQueryResult(queryResult.modifiedResult)) {
           currentResult = queryResult.modifiedResult
         } else {
-          console.warn(
-            `[query-extension] after-query subscriber ${subscriber.metadata.id} returned invalid modifiedResult shape — ignored`,
-          )
+          logger.warn('After-query subscriber returned invalid modifiedResult shape — ignored', { subscriberId: subscriber.metadata.id })
         }
       }
     } catch (error) {
-      console.error(
-        `[query-extension] after-query subscriber failed: ${subscriber.metadata.id}`,
-        error,
-      )
+      logger.error('After-query subscriber failed', { subscriberId: subscriber.metadata.id, err: error })
     }
   }
 

package/src/lib/redis/connection.ts

@@ -1,3 +1,7 @@
+import { createLogger } from '../logger'
+
+const logger = createLogger('shared').child({ component: 'redis' })
+
 /**
  * Shared Redis connection utilities.
  *
@@ -77,7 +81,7 @@ export function parseRedisUrl(url: string): ParsedRedisConnection {
     }
   } catch {
     const safeUrl = url.replace(/\/\/[^:]*:[^@]*@/, '//<redacted>@')
-    console.warn(`[redis] Failed to parse URL "${safeUrl}", falling back to localhost:6379`)
+    logger.warn('Failed to parse Redis URL, falling back to localhost:6379', { url: safeUrl })
     return { host: 'localhost', port: 6379 }
   }
 }

package/src/lib/url.ts

@@ -1,3 +1,7 @@
+import { createLogger } from './logger'
+
+const logger = createLogger('shared').child({ component: 'origin-check' })
+
 const DEFAULT_DEV_APP_URL = 'http://localhost:3000'
 
 type EnvLike = Record<string, string | undefined> & {
@@ -125,10 +129,11 @@ function logOriginDebugContext(
   nodeEnv?: string,
 ): void {
   if (level === 'warn' && nodeEnv === 'test') return
-  const log = level === 'warn' ? console.warn : console.error
+  const log = (msg: string, fields: Record<string, unknown>) =>
+    level === 'warn' ? logger.warn(msg, fields) : logger.error(msg, fields)
 
   if (typeof input === 'string') {
-    log('[origin-check] rejected string input', {
+    log('Origin check rejected string input', {
       requestUrl: input,
       rejectedOrigin: rejectedOrigin ?? null,
       allowedOrigins: Array.from(allowedOrigins),
@@ -137,14 +142,14 @@ function logOriginDebugContext(
   }
 
   if (!input) {
-    log('[origin-check] rejected empty input', {
+    log('Origin check rejected empty input', {
       rejectedOrigin: rejectedOrigin ?? null,
       allowedOrigins: Array.from(allowedOrigins),
     })
     return
   }
 
-  log('[origin-check] rejected request', {
+  log('Origin check rejected request', {
     requestUrl: input.url,
     host: input.headers.get('host'),
     forwardedHost: input.headers.get('x-forwarded-host'),
@@ -270,7 +275,7 @@ export function mapSecurityEmailUrlError(
     return { status: 400, body: { error: 'Invalid request origin' } }
   }
   if (error instanceof AppOriginConfigurationError) {
-    console.error(`[${mapping.scope}] APP_URL is required in production`)
+    logger.error('APP_URL is required in production', { scope: mapping.scope })
     return { status: 500, body: { error: mapping.configMessage } }
   }
   return null

package/src/modules/__tests__/overrides.test.ts

@@ -9,6 +9,7 @@
  * Spec: `.ai/specs/implemented/2026-05-04-modules-ts-unified-overrides.md`.
  */
 import {
+
   applyModuleOverridesFromEnabledModules,
   composeInjectionWidgetOverrides,
   composeSubscriberOverrides,
@@ -18,6 +19,20 @@ import {
   type ModuleEntryWithOverrides,
   type ModuleOverrideEntry,
 } from '../overrides'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+jest.mock('@open-mercato/shared/lib/logger', () => {
+  const mocked = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: jest.fn(),
+  }
+  mocked.child.mockImplementation(() => mocked)
+  return { createLogger: jest.fn(() => mocked) }
+})
+const loggerWarn = createLogger('shared').warn as jest.Mock
 
 beforeEach(() => {
   resetModuleOverrideAppliersForTests()
@@ -77,7 +92,7 @@ describe('applyModuleOverridesFromEnabledModules', () => {
   })
 
   it('routes built-in domains to default appliers without unwired warnings', () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerWarn.mockClear()
 
     applyModuleOverridesFromEnabledModules([
       {
@@ -93,7 +108,7 @@ describe('applyModuleOverridesFromEnabledModules', () => {
       },
     ])
 
-    const unwiredCalls = warnSpy.mock.calls.filter((args) =>
+    const unwiredCalls = loggerWarn.mock.calls.filter((args) =>
       typeof args[0] === 'string' && args[0].includes('not yet wired'),
     )
     expect(unwiredCalls).toHaveLength(0)
@@ -105,7 +120,6 @@ describe('applyModuleOverridesFromEnabledModules', () => {
       'example.todo.created.notify': null,
     })
 
-    warnSpy.mockRestore()
   })
 
   it('does NOT consume the legacy `aiAgentOverrides` / `aiToolOverrides` keys', () => {