thatcher 1.0.41 → 1.0.43

package/src/lib/query-cache.js

@@ -1,10 +1,4 @@
-const stmtCache = new Map();
-const resultCache = new Map();
-const queryCache = new Map();
-let cacheHits = 0;
-let cacheMisses = 0;
-let stmtCacheHits = 0;
-let stmtCacheMisses = 0;
+import { createCache } from './keyed-cache.js';
 
 const MAX_STMT_CACHE = 500;
 const MAX_RESULT_CACHE = 200;
@@ -23,19 +17,31 @@ const TTL_CONFIG = {
   default: DEFAULT_TTL
 };
 
+// Prepared statements never expire by time (only size-evicted), so ttlMs is
+// left unset (no expiry) -- matches the original stmtCache having no TTL check.
+const stmtCache = createCache({ maxSize: MAX_STMT_CACHE });
+// The query cache (cacheQuery) also never expired by time in the original.
+const queryCache = createCache({ maxSize: MAX_QUERY_CACHE });
+// The result cache's TTL varies PER ENTRY (by the entity it was cached under),
+// so a single fixed ttlMs on the shared primitive cannot express it directly.
+// Kept as ONE cache instance (matching the original single-Map, single
+// MAX_RESULT_CACHE=200-total ceiling -- a per-TTL-bucket split would silently
+// multiply the effective capacity, a real behaviour change) with no TTL on the
+// primitive itself; each entry's own per-entity TTL is checked here at read
+// time against a stored timestamp, exactly like the original inline check did.
+// Hit/miss counting is also done at this layer (not the primitive's own
+// built-in counters) since a ttl=0/expired lookup must count as a MISS to
+// match the original's exact cacheHits/cacheMisses semantics.
+const resultCache = createCache({ maxSize: MAX_RESULT_CACHE });
+let cacheHits = 0;
+let cacheMisses = 0;
+
 export const prepareStmt = (db, sql) => {
   const cached = stmtCache.get(sql);
-  if (cached) {
-    stmtCacheHits++;
+  if (cached !== undefined) {
     return cached;
   }
 
-  stmtCacheMisses++;
-  if (stmtCache.size >= MAX_STMT_CACHE) {
-    const firstKey = stmtCache.keys().next().value;
-    stmtCache.delete(firstKey);
-  }
-
   const stmt = db.prepare(sql);
   stmtCache.set(sql, stmt);
   return stmt;
@@ -43,7 +49,7 @@ export const prepareStmt = (db, sql) => {
 
 export const getCached = (key, entity = 'default') => {
   const entry = resultCache.get(key);
-  if (!entry) {
+  if (entry === undefined) {
     cacheMisses++;
     return null;
   }
@@ -68,11 +74,6 @@ export const setCached = (key, data, entity = 'default') => {
   const ttl = TTL_CONFIG[entity] || TTL_CONFIG.default;
   if (ttl === 0) return;
 
-  if (resultCache.size >= MAX_RESULT_CACHE) {
-    const firstKey = resultCache.keys().next().value;
-    resultCache.delete(firstKey);
-  }
-
   resultCache.set(key, { data, timestamp: Date.now() });
 };
 
@@ -84,43 +85,36 @@ export const invalidate = (pattern) => {
   }
 
   const regex = new RegExp(pattern);
-  for (const key of resultCache.keys()) {
-    if (regex.test(key)) resultCache.delete(key);
-  }
-  for (const key of queryCache.keys()) {
-    if (regex.test(key)) queryCache.delete(key);
-  }
+  resultCache.deleteWhere(key => regex.test(key));
+  queryCache.deleteWhere(key => regex.test(key));
 };
 
 export const cacheQuery = (key, fn) => {
   const cached = queryCache.get(key);
-  if (cached) return cached;
-
-  if (queryCache.size >= MAX_QUERY_CACHE) {
-    const firstKey = queryCache.keys().next().value;
-    queryCache.delete(firstKey);
-  }
+  if (cached !== undefined) return cached;
 
   const result = fn();
   queryCache.set(key, result);
   return result;
 };
 
-export const getStats = () => ({
-  cacheHits,
-  cacheMisses,
-  hitRate: cacheHits + cacheMisses > 0 ? (cacheHits / (cacheHits + cacheMisses) * 100).toFixed(2) + '%' : '0%',
-  stmtCacheHits,
-  stmtCacheMisses,
-  stmtHitRate: stmtCacheHits + stmtCacheMisses > 0 ? (stmtCacheHits / (stmtCacheHits + stmtCacheMisses) * 100).toFixed(2) + '%' : '0%',
-  stmtCacheSize: stmtCache.size,
-  resultCacheSize: resultCache.size,
-  queryCacheSize: queryCache.size
-});
+export const getStats = () => {
+  const stmtStats = stmtCache.stats();
+  return {
+    cacheHits,
+    cacheMisses,
+    hitRate: cacheHits + cacheMisses > 0 ? (cacheHits / (cacheHits + cacheMisses) * 100).toFixed(2) + '%' : '0%',
+    stmtCacheHits: stmtStats.hits,
+    stmtCacheMisses: stmtStats.misses,
+    stmtHitRate: stmtStats.hits + stmtStats.misses > 0 ? (stmtStats.hits / (stmtStats.hits + stmtStats.misses) * 100).toFixed(2) + '%' : '0%',
+    stmtCacheSize: stmtStats.size,
+    resultCacheSize: resultCache.stats().size,
+    queryCacheSize: queryCache.stats().size
+  };
+};
 
 export const clearStats = () => {
   cacheHits = 0;
   cacheMisses = 0;
-  stmtCacheHits = 0;
-  stmtCacheMisses = 0;
+  stmtCache.resetStats();
 };

package/src/lib/realtime-server.js

@@ -1,3 +1,21 @@
+// ws-broadcast channel: in-process pub/sub used by the CRUD layer to fan out
+// entity create/update/delete notifications (see src/lib/api.js, which calls
+// broadcastUpdate() on every write, and src/lib/index.js which re-exports this
+// module). Despite the "(polling mode)" log line there is no actual transport
+// here -- no WebSocket, no poll endpoint -- just an in-memory Map of
+// channel -> Set<callback>, so subscribers must live in the same process.
+//
+// This is a DIFFERENT channel from the state-transport-*.js / state-protocol.js
+// quartet (state-transport-server.js / state-transport-client.js /
+// state-transport-reconnect.js): that stack is a real `ws`-backed WebSocket
+// server+client with a structured message protocol, vector clocks, and
+// reconnect/polling-fallback semantics, but as of this writing it has ZERO
+// importers anywhere in the repo outside its own internal cross-imports --
+// nothing constructs a StateTransportServer/StateTransportClient. So today
+// state-transport-* does NOT supersede this file; this file (realtime-server.js)
+// is the one actually wired into production (src/lib/api.js), while
+// state-transport-* is a more capable but currently-unwired structured protocol.
+// Do not delete either without re-checking real importers first.
 import { createLogger } from './logger.js';
 
 const log = createLogger('[Realtime]');

package/src/lib/render-cache.js

@@ -1,8 +1,8 @@
-const cache = new Map()
+import { createCache } from './keyed-cache.js'
+
 const maxSize = 500
 const ttl = 60000
-let hits = 0
-let misses = 0
+const cache = createCache({ ttlMs: ttl, maxSize })
 
 function cacheKey(fn, args) {
   return `${fn.name}:${JSON.stringify(args)}`
@@ -12,17 +12,11 @@ export function memoize(fn) {
   return function(...args) {
     const key = cacheKey(fn, args)
     const cached = cache.get(key)
-    if (cached && Date.now() - cached.ts < ttl) {
-      hits++
-      return cached.value
+    if (cached !== undefined) {
+      return cached
     }
-    misses++
     const value = fn(...args)
-    cache.set(key, { value, ts: Date.now() })
-    if (cache.size > maxSize) {
-      const first = cache.keys().next().value
-      cache.delete(first)
-    }
+    cache.set(key, value)
     return value
   }
 }
@@ -30,25 +24,18 @@ export function memoize(fn) {
 export function invalidate(pattern) {
   if (!pattern) {
     cache.clear()
-    return cache.size
-  }
-  let count = 0
-  for (const key of cache.keys()) {
-    if (key.includes(pattern)) {
-      cache.delete(key)
-      count++
-    }
+    return 0
   }
-  return count
+  return cache.deleteWhere(key => key.includes(pattern))
 }
 
 export function getCacheStats() {
-  const total = hits + misses
+  const s = cache.stats()
   return {
-    size: cache.size,
-    hits,
-    misses,
-    hitRate: total > 0 ? (hits / total * 100).toFixed(2) + '%' : '0%',
+    size: s.size,
+    hits: s.hits,
+    misses: s.misses,
+    hitRate: (s.hits + s.misses) > 0 ? (s.hitRate * 100).toFixed(2) + '%' : '0%',
     maxSize,
     ttl
   }
@@ -56,6 +43,5 @@ export function getCacheStats() {
 
 export function clearCache() {
   cache.clear()
-  hits = 0
-  misses = 0
+  cache.resetStats()
 }

package/src/lib/{request-tracing.js → request-trace.js}

@@ -1,9 +1,19 @@
+// Merged from request-tracing.js (span/OTel-shaped tracing over the shared
+// tracer + perfProfiler) and request-tracker.js (simple duration/status
+// request+error recording into metrics-collector.js's recordRequest/
+// recordError channel). Two request-scoped tracking layers, same concern,
+// kept side by side with their original exported names unchanged.
+
 import { tracer } from './tracing.js';
-import { perfProfiler } from './perf-profiler.js';
+import { perfProfiler } from './perf.js';
 import { createLogger } from './logger.js';
+import { recordRequest, recordError } from './metrics-collector.js';
 
 const logger = createLogger('[RequestTracing]');
 
+// ---------------------------------------------------------------------------
+// From request-tracing.js
+// ---------------------------------------------------------------------------
 export function withTracing(handler) {
   return async (req, ...rest) => {
     const method = req.method || 'UNKNOWN';
@@ -208,4 +218,49 @@ export function createTracingMiddleware() {
   };
 }
 
-export default withTracing;
+export default withTracing;
+
+// ---------------------------------------------------------------------------
+// From request-tracker.js
+// ---------------------------------------------------------------------------
+function wrapHandler(handler, metadata = {}) {
+  return async (request, context) => {
+    const start = process.hrtime.bigint();
+    const method = request.method;
+    const path = new URL(request.url).pathname;
+
+    try {
+      const response = await handler(request, context);
+      const duration = Number(process.hrtime.bigint() - start) / 1000000;
+      const status = response.status || 200;
+
+      recordRequest(path, method, duration, status);
+
+      return response;
+    } catch (err) {
+      const duration = Number(process.hrtime.bigint() - start) / 1000000;
+
+      recordRequest(path, method, duration, 500);
+      recordError(path, method, err.message, err.stack);
+
+      throw err;
+    }
+  };
+}
+
+function trackRequest(path, method, duration, status) {
+  recordRequest(path, method, duration, status);
+}
+
+function trackError(path, method, error, stack) {
+  recordError(path, method, error, stack);
+}
+
+export { wrapHandler, trackRequest, trackError };
+
+if (typeof globalThis !== 'undefined') {
+  globalThis.__requestTracker = {
+    trackRequest,
+    trackError
+  };
+}

package/src/lib/response-formatter.js

@@ -35,6 +35,24 @@ export function error(message, status = HTTP.INTERNAL_ERROR, code = 'ERROR') {
   });
 }
 
+// Accepts a normalized AppError-shaped object (message/code/status/details)
+// and renders it the same way error() renders a plain message/status/code
+// triple. Pre-existing callers (withErrorHandler in lib/errors/wrap.js)
+// imported this name with no such export ever having existed here; adding
+// it now is the real fix for what was previously a dead, never-taken error
+// path (nothing ever exercised it directly, so the gap went unnoticed).
+export function apiError(err) {
+  const status = err?.status || err?.statusCode || HTTP.INTERNAL_ERROR;
+  const code = err?.code || 'ERROR';
+  const message = err?.message || 'An unexpected error occurred';
+  const body = { error: message, code };
+  if (err?.details) body.details = err.details;
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
 export function withMetadata(data, status, type = 'success') {
   return { ...data, _meta: { status, type, timestamp: Date.now() } };
 }

package/src/lib/route-helpers.js

@@ -3,7 +3,7 @@ import { getSpec, getNavItems } from '@/config/spec-helpers';
 import { get, getChildren } from '@/engine';
 import { can } from '@/services/permission.service';
 import { withPageAuth } from '@/lib/auth-middleware';
-import { notFound } from '@/lib/next-polyfills';
+import { notFound } from '@/lib/next-shim';
 import { loadFormOptions } from '@/lib/utils';
 
 export { withPageAuth as requireEntityAccess };

package/src/lib/state-protocol.js

@@ -1,3 +1,16 @@
+// state-sync channel: message-type vocabulary + VectorClock + schema validation
+// shared by state-transport-server.js / state-transport-client.js /
+// state-transport-reconnect.js. This is a structured, reconnect-aware
+// WebSocket protocol (real `ws` transport, IP/rate-limited via
+// connection-guard.js, exponential-backoff client reconnect with a polling
+// fallback) -- distinct from the simpler in-process pub/sub in
+// realtime-server.js (the "ws-broadcast" channel actually wired into the CRUD
+// write path via src/lib/api.js). As of this writing, grepping the whole repo
+// found ZERO importers of this quartet outside their own internal cross-imports
+// (state-transport-client.js imports state-transport-reconnect.js; both import
+// this file) -- nothing external constructs a StateTransportServer/Client, so
+// this stack is currently unwired/dormant rather than superseding
+// realtime-server.js. Keep both; re-check importers before deleting either.
 const MESSAGE_TYPES = {
   STATE_UPDATE: 'state_update',
   STATE_SNAPSHOT: 'state_snapshot',

package/src/lib/state-transport-client.js

@@ -1,3 +1,9 @@
+// state-sync channel (client side): browser WebSocket client with
+// exponential-backoff reconnect + polling fallback, part of the
+// state-protocol.js quartet. See the header comment in state-protocol.js --
+// this is a structured, reconnect-aware protocol distinct from
+// realtime-server.js's simple in-process pub/sub. Zero real importers found
+// repo-wide as of this writing; currently dormant/unwired.
 import Protocol from './state-protocol.js'
 import { CONFIG, ReconnectManager } from './state-transport-reconnect.js'
 import { createLogger } from './logger.js'

package/src/lib/state-transport-reconnect.js

@@ -1,3 +1,8 @@
+// state-sync channel (reconnect logic): exponential-backoff + polling-fallback
+// manager consumed by state-transport-client.js, part of the state-protocol.js
+// quartet. See the header comment in state-protocol.js for the full
+// ws-broadcast vs state-sync distinction. Zero real importers repo-wide
+// outside this quartet's own internal cross-imports as of this writing.
 import Protocol from './state-protocol.js'
 
 const CONFIG = {

package/src/lib/state-transport-server.js

@@ -1,3 +1,11 @@
+// state-sync channel (server side): real `ws`-backed WebSocketServer with
+// connection-guard IP/rate limiting, part of the state-protocol.js quartet.
+// See the header comment in state-protocol.js for the full picture -- this is
+// a structured, reconnect-aware state-sync protocol, DIFFERENT from and not a
+// replacement for realtime-server.js's simple in-process pub/sub
+// (the "ws-broadcast" channel actually used by the CRUD write path). As of
+// this writing this file has zero real importers repo-wide; nothing
+// constructs a StateTransportServer today.
 import { WebSocketServer } from 'ws'
 import { EventEmitter } from 'events'
 import Protocol from '@/lib/state-protocol.js'

package/src/lib/utils.js

@@ -1,4 +1,4 @@
-import { list } from './busybase-store.js';
+import { list } from './busybase/store.js';
 import { getSpec } from '../config/spec-helpers.js';
 
 // Ported from moonlanding. engagement refs get a richer label and skip archived rows; failures degrade to [].

package/src/lib/{validate.js → validation/entity-validators.js}

@@ -1,16 +1,17 @@
 // Adapted from moonlanding/src/lib/validate.js
+// Entity/spec-driven field, record, and status-transition validation.
 
-import { getSpec } from '../config/spec-helpers.js';
-import { isValidEmail as checkEmailFormat, isValidEmail } from './validators.js';
-import { getValidTransitions } from './status-helpers.js';
-import { isBeforeDate } from './date-utils.js';
+import { getSpec } from '@/config/spec-helpers';
+import { isValidEmail } from '@/lib/validation/format-validators';
+import { getValidTransitions } from '@/lib/status-helpers';
+import { isBeforeDate } from '@/lib/date-utils';
 
-// Re-export so consumers can reach the email validator from validate.js (parity with moon)
+// Re-export so consumers can reach the email validator from entity-validators.js (parity with moon)
 export { isValidEmail };
 
 const HTML_ESC = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
 
-function sanitizeHtml(str) {
+export function sanitizeHtml(str) {
   return typeof str === 'string' ? str.replace(/[&<>"']/g, c => HTML_ESC[c]) : str;
 }
 
@@ -50,7 +51,7 @@ export async function validateField(fieldDef, value, options = {}) {
       return { valid: true };
     }
     try {
-      const { getBy } = await import('./busybase-store.js');
+      const { getBy } = await import('@/lib/busybase/store');
       const refTable = fieldDef.ref === 'user' ? 'users' : fieldDef.ref;
       if (!(await getBy(refTable, 'id', value))) {
         return {
@@ -141,7 +142,7 @@ async function checkUnique(fieldDef, value, { fieldName, entityName, existingRec
   const existingValue = existingRecord?.[fieldName];
   if (value === existingValue) return null;
   try {
-    const { getBy } = await import('./busybase-store.js');
+    const { getBy } = await import('@/lib/busybase/store');
     const table = entityName === 'user' ? 'users' : entityName;
     const dup = await getBy(table, fieldName, value);
     if (dup && (!existingRecord || dup.id !== existingRecord.id)) {

package/src/lib/validation/index.js

@@ -16,4 +16,4 @@ export {
   validateDeadline,
   sanitizeData,
   sanitizeHtml
-} from '@/lib/validate';
+} from '@/lib/validation/entity-validators';

package/src/lib/validation/security-validators.js

@@ -1,4 +1,4 @@
-import { sanitizeHtml } from '@/lib/validate';
+import { sanitizeHtml } from '@/lib/validation/entity-validators';
 
 const XSS_PATTERNS = [
   /<script[^>]*>.*?<\/script>/gi,

package/src/lib/validation-middleware.js

@@ -1,4 +1,4 @@
-import { NextResponse } from '@/lib/next-polyfills';
+import { NextResponse } from '@/lib/next-shim';
 import {
   detectXSS,
   detectSQLInjection,
@@ -7,7 +7,7 @@ import {
   rateLimitCheck,
   validateCSRFToken
 } from '@/lib/validation';
-import { validateEntity, validateUpdate, hasErrors } from '@/lib/validate';
+import { validateEntity, validateUpdate, hasErrors } from '@/lib/validation/entity-validators';
 
 export async function validateRequest(request, options = {}) {
   const { requireCSRF = true, rateLimit = { max: 100, window: 60000 }, entityName = null } = options;

package/src/lib/workflow-engine.js

@@ -1,7 +1,27 @@
-import { get, update, create } from './busybase-store.js';
+// Plain-function entity lifecycle/workflow engine: reads a `config.workflows[name]`
+// definition (stages with forward/backward/requires_role/entry/readonly/order/
+// locks/actions) and validates+applies transitions against a busybase-backed
+// entity record. THIS IS THE LIVE PATH: its `validateTransition` is called from
+// src/lib/events-engine.js to gate an `engagement_lifecycle` stage change, a real
+// production call site. It is also re-exported from src/lib/index.js (the top-level
+// Thatcher class delegates `thatcher.transition()`/`thatcher.getAvailableTransitions()`
+// here -- see src/index.js).
+//
+// xstate-workflow-engine.js implements the SAME job (same config shape, same
+// validateTransition/getAvailableTransitions/transition/getStateField/
+// getStageLabels/getStateLocks/getStateActions exports, nearly line-for-line
+// duplicated validation branches) PLUS a real xstate machine + live per-entity
+// actors on top. Despite the more capable implementation, as of this writing its
+// only importers repo-wide are a debug route (src/app/api/debug/[[...path]]/route.js,
+// which hard-disables itself when NODE_ENV=production) and a root-level manual
+// test.js script -- neither is a production call site. So xstate-workflow-engine.js
+// does NOT currently supersede this file; if anything the reverse holds (this file
+// is live, that one is dormant/debug-only). Re-check import sites before treating
+// either as the "old" one.
+import { get, update, create } from './busybase/store.js';
 import { getConfigEngineSync } from './config-generator-engine.js';
 import { executeHook } from './hook-engine.js';
-import { AppError } from './error-handler.js';
+import { AppError } from './errors/index.js';
 import { HTTP } from '../config/constants.js';
 import { createLogger } from './logger.js';
 
@@ -137,7 +157,7 @@ export async function transition(entityType, entityId, workflowName, toState, us
   }
 
   // Dynamically import write engine to avoid circular dependency
-  const { update: updateRecord } = await import('./busybase-store.js');
+  const { update: updateRecord } = await import('./busybase/store.js');
   const updated = await updateRecord(entityType, entityId, updates, user);
 
   executeHook(`transition:${entityType}`, {

package/src/lib/xstate-workflow-engine.js

@@ -1,7 +1,23 @@
+// xstate-backed workflow engine: reads the SAME `config.workflows[name]`
+// definition as workflow-engine.js and duplicates its plain-function exports
+// (validateTransition/getAvailableTransitions/transition/getStateField/
+// getStageLabels/getStateLocks/getStateActions, nearly line-for-line the same
+// validation logic) but additionally compiles a real xstate machine
+// (compileWorkflow) and manages live per-entity actors (createActorForEntity/
+// sendEvent/getSnapshot/getActiveActors).
+//
+// NOT currently the live path. As of this writing its only importers repo-wide
+// are src/app/api/debug/[[...path]]/route.js (getXStateWorkflowEngine -- and that
+// whole route hard-disables itself when NODE_ENV=production) and a root-level
+// manual `test.js` script outside src/ -- neither is a production call site.
+// workflow-engine.js is the one actually wired into production (called from
+// src/lib/events-engine.js and re-exported by src/index.js's Thatcher class).
+// This file does NOT supersede workflow-engine.js; treat it as a dormant/
+// debug-only alternate implementation until a real call site adopts it.
 import { createMachine, createActor, assign, fromPromise, sendParent } from 'xstate';
 import { getConfigEngineSync } from './config-generator-engine.js';
 import { hookEngine } from './hook-engine.js';
-import { AppError } from './error-handler.js';
+import { AppError } from './errors/index.js';
 import { HTTP } from '../config/constants.js';
 import { createLogger } from './logger.js';
 
@@ -385,7 +401,7 @@ export function getAvailableTransitions(workflowName, currentState, user, record
 }
 
 export async function transition(entityType, entityId, workflowName, toState, user, reason = '') {
-  const { get, update: updateRecord } = await import('./busybase-store.js');
+  const { get, update: updateRecord } = await import('./busybase/store.js');
 
   const record = await get(entityType, entityId);
   if (!record) throw new AppError('Record not found', 'NOT_FOUND', HTTP.NOT_FOUND);

package/src/services/collaborator-role.service.js

@@ -1,7 +1,7 @@
 // Extracted from moonlanding/src/services/collaborator-role.service.js
 
-import { list, get, update, create } from '../lib/busybase-store.js';
-import { AppError } from '../lib/error-handler.js';
+import { list, get, update, create } from '../lib/busybase/store.js';
+import { AppError } from '../lib/errors/index.js';
 import { HTTP } from '../config/constants.js';
 
 const COLLABORATOR_ROLE_PERMISSIONS = {

package/src/services/notification-engine.js

@@ -11,7 +11,7 @@ export function getNotificationTemplate(name) {
 }
 
 export async function createNotification(notification) {
-  const { create } = await import('../lib/busybase-store.js');
+  const { create } = await import('../lib/busybase/store.js');
   return create('notification', {
     ...notification,
     created_at: Math.floor(Date.now() / 1000),
@@ -66,14 +66,14 @@ export async function sendNotification(type, userId, context = {}, options = {})
 }
 
 export async function markNotificationRead(notificationId, userId) {
-  const { update } = await import('../lib/busybase-store.js');
+  const { update } = await import('../lib/busybase/store.js');
   return update('notification', notificationId, {
     read_at: Math.floor(Date.now() / 1000),
   });
 }
 
 export async function getUnreadCount(userId) {
-  const { list } = await import('../lib/busybase-store.js');
+  const { list } = await import('../lib/busybase/store.js');
   return (await list('notification', {
     user_id: userId,
     read_at: null,
@@ -83,13 +83,13 @@ export async function getUnreadCount(userId) {
 // Resolve a `recipients` token (a role/group name used across events-engine.js
 // call sites, e.g. 'client_users', 'team_members', 'collaborator') to a list of
 // user records to notify. There is no dedicated recipient-resolution engine in
-// this codebase yet, so this composes the existing busybase-store queries the
+// this codebase yet, so this composes the existing busybase/store queries the
 // same way the rest of the app looks up users -- a single explicit user object
 // on the context (context.recipientUser / a matching *_id field) is honored
 // directly, and a bare role/group token that cannot be resolved to concrete
 // users is logged and skipped rather than silently guessed at.
 async function resolveRecipients(recipients, context) {
-  const { list, get } = await import('../lib/busybase-store.js');
+  const { list, get } = await import('../lib/busybase/store.js');
 
   if (context.recipientUser) return [context.recipientUser];
   if (context.collaborator?.email) return [context.collaborator];

package/src/services/permission.service.js

@@ -1,7 +1,7 @@
 // Adapted from moonlanding/src/services/permission.service.js
 
 import { getCollaboratorRole, checkCollaboratorAccess } from '../services/collaborator-role.service.js';
-import { PermissionError } from '../lib/error-handler.js';
+import { PermissionError } from '../lib/errors/index.js';
 import { getConfigEngineSync } from '../lib/config-generator-engine.js';
 
 class PermissionService {

package/src/ui/format-helpers.js

@@ -1,4 +1,5 @@
 import { STAGE_COLORS, STATUS_COLORS } from './render-helpers.js';
+export { esc } from './render-helpers.js';
 
 export function formatDate(ts, opts) {
   if (!ts) return '-';
@@ -129,7 +130,3 @@ export function emptyState(message, iconName) {
     <div style="font-size:0.88rem;font-weight:500">${message || 'No items found'}</div>
   </div>`;
 }
-
-export function esc(s) {
-  return String(s ?? '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
-}

package/src/ui/highlight-threading-renderer.js

@@ -1,6 +1,6 @@
 import { page } from '@/ui/layout.js';
 import { canEdit } from '@/ui/permissions-ui.js';
-import { reviewZoneNav } from '@/ui/review-zone-nav.js';
+import { reviewZoneNav } from '@/ui/review/zone-nav.js';
 import { esc } from '@/ui/render-helpers.js';
 import { SPACING, renderStatsRow, renderPageHeader, renderButton, renderEmptyState } from '@/ui/spacing-system.js';