thatcher 1.0.4

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

@@ -0,0 +1,205 @@
+/**
+ * Collaborator Role Service - Role-based access control for review collaborators
+ * Extracted from moonlanding/src/services/collaborator-role.service.js
+ */
+
+import { list, get, update, create } from '../lib/query-engine.js';
+import { AppError } from '../lib/error-handler.js';
+import { HTTP } from '../config/constants.js';
+
+const COLLABORATOR_ROLE_PERMISSIONS = {
+  viewer: ['view', 'view_highlights', 'view_pdfs'],
+  commenter: ['view', 'view_highlights', 'view_pdfs', 'add_notes', 'add_comments'],
+  reviewer: [
+    'view', 'view_highlights', 'view_pdfs', 'add_notes', 'add_comments',
+    'edit_highlights', 'resolve_highlights', 'reopen_highlights', 'create_highlights',
+    'delete_own_highlights', 'manage_highlights'
+  ],
+  manager: [
+    'view', 'view_highlights', 'view_pdfs', 'add_notes', 'add_comments',
+    'edit_highlights', 'resolve_highlights', 'reopen_highlights', 'create_highlights',
+    'delete_highlights', 'manage_highlights', 'manage_collaborators', 'manage_flags',
+    'manage_templates', 'manage_checklists', 'archive', 'assign_roles', 'approve_changes'
+  ],
+};
+
+/**
+ * Get active collaborator role
+ * @param {string} collaboratorId
+ * @returns {object|null}
+ */
+export function getCollaboratorRole(collaboratorId) {
+  if (!collaboratorId) return null;
+  const collaborator = get('collaborator', collaboratorId);
+  if (!collaborator) return null;
+
+  if (collaborator.primary_role_id) {
+    const role = get('collaborator_role', collaborator.primary_role_id);
+    if (role && role.is_active) return role;
+  }
+
+  const roles = list('collaborator_role')
+    .filter(r => r.collaborator_id === collaboratorId && r.is_active);
+
+  if (roles.length === 0) return null;
+
+  roles.sort((a, b) => b.assigned_at - a.assigned_at);
+  const activeRole = roles[0];
+
+  if (collaborator.primary_role_id !== activeRole.id) {
+    update('collaborator', collaboratorId, {
+      primary_role_id: activeRole.id,
+      is_manager: activeRole.role_type === 'manager'
+    });
+  }
+  return activeRole;
+}
+
+/**
+ * Check if collaborator has permission for action
+ * @param {string} collaboratorId
+ * @param {string} permission
+ * @returns {boolean}
+ */
+export function hasCollaboratorPermission(collaboratorId, permission) {
+  const role = getCollaboratorRole(collaboratorId);
+  if (!role) return false;
+  const perms = COLLABORATOR_ROLE_PERMISSIONS[role.role_type];
+  return perms ? perms.includes(permission) : false;
+}
+
+/**
+ * Check collaborator access for specific action (with optional record)
+ * @param {string} collaboratorId
+ * @param {string} action
+ * @param {object} [record]
+ * @returns {boolean}
+ */
+export function checkCollaboratorAccess(collaboratorId, action, record = null) {
+  const role = getCollaboratorRole(collaboratorId);
+  if (!role) return false;
+  const perms = COLLABORATOR_ROLE_PERMISSIONS[role.role_type];
+  if (!perms) return false;
+  if (perms.includes(action)) return true;
+  if (action === 'delete_highlights' && perms.includes('delete_own_highlights') && record) {
+    const collaborator = get('collaborator', collaboratorId);
+    return record.created_by === collaborator?.user_id;
+  }
+  return false;
+}
+
+/**
+ * Get role history for collaborator
+ * @param {string} collaboratorId
+ * @returns {Array}
+ */
+export function getCollaboratorRoleHistory(collaboratorId) {
+  if (!collaboratorId) return [];
+  return list('collaborator_role')
+    .filter(r => r.collaborator_id === collaboratorId)
+    .sort((a, b) => b.assigned_at - a.assigned_at);
+}
+
+/**
+ * Get permissions for a role type
+ * @param {string} roleType
+ * @returns {Array<string>}
+ */
+export function getCollaboratorRolePermissions(roleType) {
+  return COLLABORATOR_ROLE_PERMISSIONS[roleType] || [];
+}
+
+/**
+ * Check if user role can assign target role
+ * @param {string} userRole
+ * @param {string} targetRoleType
+ * @returns {boolean}
+ */
+export function canAssignRole(userRole, targetRoleType) {
+  return ['partner', 'manager'].includes(userRole);
+}
+
+/**
+ * Add a collaborator to a review
+ * @param {string} reviewId
+ * @param {string} email
+ * @param {object} options
+ * @returns {object}
+ */
+export function addCollaborator(reviewId, email, options = {}) {
+  const { expiresAt, createdBy = 'system', reason = '' } = options;
+  const nowSeconds = Math.floor(Date.now() / 1000);
+  const isPermanent = !expiresAt;
+
+  if (expiresAt) {
+    const maxAllowed = nowSeconds + (30 * 24 * 60 * 60);
+    if (expiresAt <= nowSeconds) throw new Error('Expiry date must be in the future');
+    if (expiresAt > maxAllowed) throw new Error('Expiry date cannot exceed 30 days from now');
+  }
+
+  return create('collaborator', {
+    review_id: reviewId,
+    email,
+    expires_at: expiresAt || null,
+    is_permanent: isPermanent,
+    created_at: nowSeconds,
+    created_by: createdBy,
+    reason,
+    access_type: isPermanent ? 'permanent' : 'temporary',
+  }, { id: createdBy, role: 'partner' });
+}
+
+/**
+ * Get collaborators for a review
+ * @param {string} reviewId
+ * @returns {Array}
+ */
+export function getReviewCollaborators(reviewId) {
+  const collaborators = list('collaborator', { review_id: reviewId });
+  const nowSeconds = Math.floor(Date.now() / 1000);
+
+  return collaborators.map(c => ({
+    id: c.id,
+    email: c.email,
+    accessType: c.access_type,
+    isPermanent: c.is_permanent,
+    expiresAt: c.expires_at,
+    daysUntilExpiry: c.expires_at ? Math.ceil((c.expires_at - nowSeconds) / 86400) : null,
+    isExpired: !c.is_permanent && c.expires_at && c.expires_at <= nowSeconds,
+    createdAt: c.created_at,
+    createdBy: c.created_by,
+  }));
+}
+
+/**
+ * Revoke collaborator access
+ * @param {string} collaboratorId
+ * @param {string} [reason='manual_revoke']
+ * @param {string} [revokedBy='system']
+ * @returns {boolean}
+ */
+export function revokeCollaborator(collaboratorId, reason = 'manual_revoke', revokedBy = 'system') {
+  const collaborator = get('collaborator', collaboratorId);
+  if (!collaborator) throw new Error('Collaborator not found');
+
+  update('collaborator', collaboratorId, {
+    revoked_at: Math.floor(Date.now() / 1000),
+    revoked_by: revokedBy,
+    revocation_reason: reason,
+    access_type: 'revoked',
+  }, { id: revokedBy, role: 'partner' });
+
+  return true;
+}
+
+export default {
+  getCollaboratorRole,
+  hasCollaboratorPermission,
+  checkCollaboratorAccess,
+  getCollaboratorRoleHistory,
+  getCollaboratorRolePermissions,
+  canAssignRole,
+  addCollaborator,
+  getReviewCollaborators,
+  revokeCollaborator,
+};

package/src/services/email-sender.js

@@ -0,0 +1,105 @@
+/**
+ * Email Sender - SMTP email delivery with templates
+ * Uses nodemailer
+ */
+
+import nodemailer from 'nodemailer';
+import { buildConfig } from '../config/env.js';
+
+let transporter = null;
+
+/**
+ * Initialize email transporter
+ * @param {object} [config]
+ */
+export function initEmail(config = null) {
+  const cfg = config || buildConfig();
+
+  if (!cfg.email.smtp.user || !cfg.email.smtp.password) {
+    console.warn('[Email] SMTP credentials not configured');
+    return null;
+  }
+
+  transporter = nodemailer.createTransport({
+    host: cfg.email.smtp.host,
+    port: cfg.email.smtp.port,
+    secure: cfg.email.smtp.port === 465, // true for 465, false for other ports
+    auth: {
+      user: cfg.email.smtp.user,
+      pass: cfg.email.smtp.password,
+    },
+  });
+
+  return transporter;
+}
+
+/**
+ * Get initialized transporter
+ * @returns {object}
+ */
+export function getTransporter() {
+  if (!transporter) initEmail();
+  return transporter;
+}
+
+/**
+ * Send email
+ * @param {object} options - { to, subject, text, html, attachments }
+ * @returns {Promise<object>}
+ */
+export async function sendEmail(options) {
+  const transporter = getTransporter();
+  if (!transporter) {
+    throw new Error('Email not configured');
+  }
+
+  const from = buildConfig().email.from;
+
+  const info = await transporter.sendMail({
+    from,
+    ...options,
+  });
+
+  console.log('[Email] Sent:', info.messageId);
+  return info;
+}
+
+/**
+ * Send templated email
+ * @param {string} templateName
+ * @param {string} to
+ * @param {object} context
+ * @returns {Promise<object>}
+ */
+export async function sendTemplatedEmail(templateName, to, context = {}) {
+  // Templates could be loaded from config or files
+  const templates = getTemplates();
+  const template = templates[templateName];
+
+  if (!template) {
+    throw new Error(`Email template not found: ${templateName}`);
+  }
+
+  const subject = template.subject.replace(/\{\{(\w+)\}\}/g, (_, key) => context[key] || '');
+  const text = template.text?.replace(/\{\{(\w+)\}\}/g, (_, key) => context[key] || '');
+  const html = template.html?.replace(/\{\{(\w+)\}\}/g, (_, key) => context[key] || '');
+
+  return sendEmail({ to, subject, text, html });
+}
+
+/**
+ * Simple templates (could be loaded from config)
+ * @returns {object}
+ */
+function getTemplates() {
+  return {
+    notification: {
+      subject: 'Notification from {{appName}}',
+      text: '{{message}}\n\n— {{appName}}',
+    },
+    invitation: {
+      subject: 'You\'ve been invited to {{appName}}',
+      text: '{{inviter}} has invited you to join {{appName}}.\n\nSign up: {{url}}',
+    },
+  };
+}

package/src/services/notification-engine.js

@@ -0,0 +1,110 @@
+/**
+ * Notification Engine - In-app notifications, email triggers
+ */
+
+import { getTransporter, sendEmail } from './email-sender.js';
+import { getConfigEngineSync } from '../lib/config-generator-engine.js';
+import { executeHook } from '../lib/hook-engine.js';
+
+/**
+ * Get notification template from config
+ */
+export function getNotificationTemplate(name) {
+  const engine = getConfigEngineSync();
+  return engine.generateNotificationHandler(name);
+}
+
+/**
+ * Create notification record
+ */
+export async function createNotification(notification) {
+  const { create } = await import('../lib/query-engine-write.js');
+  return create('notification', {
+    ...notification,
+    created_at: Math.floor(Date.now() / 1000),
+    read_at: null,
+  }, { id: notification.created_by || 'system', role: 'system' });
+}
+
+/**
+ * Send notification to user (in-app + optional email)
+ */
+export async function sendNotification(type, userId, context = {}, options = {}) {
+  const template = getNotificationTemplate(type);
+  if (!template) {
+    console.warn(`[Notification] Template not found: ${type}`);
+    return null;
+  }
+
+  const title = interpolate(template.title, context);
+  const message = interpolate(template.message, context);
+
+  // Create notification record
+  const notification = await createNotification({
+    type,
+    user_id: userId,
+    title,
+    message,
+    data: context,
+    entity_type: options.entityType,
+    entity_id: options.entityId,
+    created_by: context.userId || 'system',
+  });
+
+  // Send email if enabled
+  if (options.sendEmail !== false) {
+    try {
+      const { getUser } = await import('../engine.server.js');
+      const user = await getUser(userId);
+      if (user?.email) {
+        await sendEmail({
+          to: user.email,
+          subject: `[${context.appName || 'App'}] ${title}`,
+          text: `${message}\n\n---\nView in app: ${context.url || '/'}`,
+        });
+      }
+    } catch (err) {
+      console.error('[Notification] Email failed:', err.message);
+    }
+  }
+
+  executeHook(`notification:${type}`, {
+    notification,
+    user: { id: userId },
+    context,
+  }).catch(console.error);
+
+  return notification;
+}
+
+/**
+ * Mark notification as read
+ */
+export async function markNotificationRead(notificationId, userId) {
+  const { update } = await import('../lib/query-engine-write.js');
+  return update('notification', notificationId, {
+    read_at: Math.floor(Date.now() / 1000),
+  }, { id: userId, role: 'user' });
+}
+
+/**
+ * Get unread count for user
+ */
+export async function getUnreadCount(userId) {
+  const { list } = await import('../lib/query-engine.js');
+  return list('notification', {
+    user_id: userId,
+    read_at: null,
+  }).length;
+}
+
+/**
+ * Interpolate {{key}} in template strings
+ */
+function interpolate(template, context) {
+  if (!template) return '';
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const val = context[key];
+    return val !== undefined ? String(val) : `{{${key}}}`;
+  });
+}

package/src/services/permission.service.js

@@ -0,0 +1,181 @@
+/**
+ * Permission Service - Authorization logic
+ * Adapted from moonlanding/src/services/permission.service.js
+ */
+
+import { getCollaboratorRole, checkCollaboratorAccess } from '../services/collaborator-role.service.js';
+import { PermissionError } from './error-handler.js';
+import { getConfigEngineSync } from './config-generator-engine.js';
+
+class PermissionService {
+  /**
+   * Check if user can perform action on entity spec
+   * @param {object} user
+   * @param {object} spec
+   * @param {string} action
+   * @returns {boolean}
+   */
+  can(user, spec, action) {
+    if (!user) return false;
+    if (!spec?.access?.[action]) return true; // No restriction defined = allow
+    return spec.access[action].includes(user.role);
+  }
+
+  /**
+   * Require permission (throw if denied)
+   * @param {object} user
+   * @param {object} spec
+   * @param {string} action
+   */
+  require(user, spec, action) {
+    if (!this.can(user, spec, action)) {
+      throw new PermissionError(`Cannot ${action} ${spec?.name || 'unknown'}`);
+    }
+  }
+
+  /**
+   * Check field-level access
+   * @param {object} user
+   * @param {object} spec
+   * @param {string} fieldName
+   * @param {string} action - 'view' or 'edit'
+   * @returns {boolean}
+   */
+  checkFieldAccess(user, spec, fieldName, action) {
+    if (!user) return false;
+    const perm = spec.fieldPermissions?.[fieldName];
+    if (!perm) return true;
+    const allowed = perm[action];
+    if (allowed === 'all') return true;
+    return Array.isArray(allowed) && allowed.includes(user.role);
+  }
+
+  /**
+   * Check row-level access
+   * @param {object} user
+   * @param {object} spec
+   * @param {object} record
+   * @returns {boolean}
+   */
+  checkRowAccess(user, spec, record) {
+    if (!user) return false;
+    const rowAccess = spec.rowAccess || spec.row_access;
+    if (!rowAccess) return true;
+
+    const roles = getConfigEngineSync().getRoles();
+    const partnerRole = Object.keys(roles).find(r => roles[r].hierarchy === 0);
+    const clientAdminRole = Object.keys(roles).find(r => r.includes('client') && r.includes('admin'));
+    const clientUserRole = Object.keys(roles).find(r => r === 'client_user');
+
+    const scope = rowAccess.scope || rowAccess;
+
+    if (scope === 'team' && record.team_id && user.team_id && record.team_id !== user.team_id) {
+      return false;
+    }
+
+    if (scope === 'assigned' && record.assigned_to && record.assigned_to !== user.id && user.role !== partnerRole) {
+      return false;
+    }
+
+    if (scope === 'assigned_or_team' && user.role !== partnerRole) {
+      const assignedMatch = record.assigned_to && record.assigned_to === user.id;
+      const teamMatch = record.team_id && user.team_id && record.team_id === user.team_id;
+      if (!assignedMatch && !teamMatch) return false;
+    }
+
+    if (scope === 'client') {
+      if ((clientAdminRole && user.role === clientAdminRole) || (clientUserRole && user.role === clientUserRole)) {
+        if (record.client_id && user.client_id && record.client_id !== user.client_id) return false;
+        if (clientUserRole && user.role === clientUserRole && !this.checkAssignment(user, spec, record)) {
+          return false;
+        }
+      } else if (record.client_id && user.client_ids && !user.client_ids.includes(record.client_id)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Filter records by row access
+   * @param {object} user
+   * @param {object} spec
+   * @param {Array} records
+   * @returns {Array}
+   */
+  filterRecords(user, spec, records) {
+    if (!user || !Array.isArray(records)) return records;
+    return records.filter(r => this.checkRowAccess(user, spec, r));
+  }
+
+  /**
+   * Filter fields by field-level permissions
+   * @param {object} user
+   * @param {object} spec
+   * @param {object} record
+   * @returns {object}
+   */
+  filterFields(user, spec, record) {
+    if (!user) return record;
+    const filtered = {};
+    for (const [key, value] of Object.entries(record)) {
+      if (spec.fields?.[key]?.hidden) continue;
+      if (this.checkFieldAccess(user, spec, key, 'view')) {
+        filtered[key] = value;
+      }
+    }
+    return filtered;
+  }
+
+  /**
+   * Enforce edit permissions on data
+   * @param {object} user
+   * @param {object} spec
+   * @param {object} data
+   */
+  enforceEditPermissions(user, spec, data) {
+    if (!user) throw new PermissionError(`Cannot edit ${spec.name}`);
+    if (!this.can(user, spec, 'edit')) throw new PermissionError(`Cannot edit ${spec.name}`);
+
+    for (const field of Object.keys(data)) {
+      if (!this.checkFieldAccess(user, spec, field, 'edit')) {
+        throw new PermissionError(`Cannot edit ${spec.name}.${field}`);
+      }
+    }
+  }
+
+  /**
+   * Check if user owns record
+   * @param {object} user
+   * @param {object} spec
+   * @param {object} record
+   * @returns {boolean}
+   */
+  checkOwnership(user, spec, record) {
+    if (!record) return false;
+    return record.created_by === user.id || record.user_id === user.id;
+  }
+
+  /**
+   * Check assignment for client access
+   * @param {object} user
+   * @param {object} spec
+   * @param {object} record
+   * @returns {boolean}
+   */
+  checkAssignment(user, spec, record) {
+    // Simplified - check if user is assigned to record
+    return record.assigned_to === user.id || record.team_id === user.team_id;
+  }
+
+  /**
+   * Check collaborator-style permission
+   */
+  hasCollaboratorPermission(collaboratorId, permission) {
+    return getCollaboratorRole(collaboratorId)?.permissions?.includes(permission);
+  }
+}
+
+export const permissionService = new PermissionService();
+export default permissionService;

package/src/ui/advanced-search-renderer.js

@@ -0,0 +1,42 @@
+import { statusLabel } from '@/ui/renderer.js';
+import { page } from '@/ui/layout.js';
+import { fmtDate } from '@/ui/render-helpers.js';
+
+function resultCard(item, entityType) {
+  const sts = item.status ? statusLabel(item.status) : '';
+  const title = item.name || item.title || 'Untitled';
+  const subtitle = item.client_name || item.engagement_name || item.email || '';
+  const date = fmtDate(item.created_at);
+  const typeLabel = entityType.charAt(0).toUpperCase() + entityType.slice(1);
+  return `<div class="card-clean" style="margin-bottom:8px;cursor:pointer" data-navigate="/${entityType}/${item.id}"><div class="card-clean-body" style="padding:0.75rem"><div class="flex items-start justify-between"><div class="flex-1"><div class="flex items-center gap-2 mb-1"><span class="badge badge-sm bg-gray-100 text-gray-600">${typeLabel}</span>${sts}</div><div class="font-medium">${title}</div>${subtitle ? `<div class="text-xs text-gray-500 mt-0.5">${subtitle}</div>` : ''}</div><div class="text-xs text-gray-400">${date}</div></div></div></div>`;
+}
+
+function filterPanel(teams, stages) {
+  const teamOpts = teams.map(t => `<option value="${t.id}">${t.name}</option>`).join('');
+  const stageOpts = stages.map(s => `<option value="${s}">${s.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase())}</option>`).join('');
+  return `<div class="card-clean" style="margin-bottom:1.5rem"><div class="card-clean-body"><div class="grid grid-cols-1 md:grid-cols-4 gap-3"><div><label class="text-xs font-medium text-gray-600 block mb-1" for="search-query">Search</label><input type="text"  id="search-query" class="input input-bordered input-sm w-full" placeholder="Search across all entities..."/></div><div><label class="text-xs font-medium text-gray-600 block mb-1" for="filter-entity">Entity Type</label><select id="filter-entity" class="select select-bordered select-sm w-full"><option value="">All Types</option><option value="engagement">Engagements</option><option value="client">Clients</option><option value="rfi">RFIs</option><option value="review">Reviews</option><option value="user">Users</option></select></div><div><label class="text-xs font-medium text-gray-600 block mb-1" for="filter-status">Status</label><select id="filter-status" class="select select-bordered select-sm w-full"><option value="">All Statuses</option><option value="active">Active</option><option value="pending">Pending</option><option value="completed">Completed</option><option value="archived">Archived</option></select></div><div><label class="text-xs font-medium text-gray-600 block mb-1" for="filter-stage">Stage</label><select id="filter-stage" class="select select-bordered select-sm w-full"><option value="">All Stages</option>${stageOpts}</select></div></div><div class="grid grid-cols-1 md:grid-cols-4 gap-3 mt-3"><div><label class="text-xs font-medium text-gray-600 block mb-1" for="filter-team">Team</label><select id="filter-team" class="select select-bordered select-sm w-full"><option value="">All Teams</option>${teamOpts}</select></div><div><label class="text-xs font-medium text-gray-600 block mb-1" for="filter-from">Date From</label><input type="date"  id="filter-from" class="input input-bordered input-sm w-full"/></div><div><label class="text-xs font-medium text-gray-600 block mb-1" for="filter-to">Date To</label><input type="date"  id="filter-to" class="input input-bordered input-sm w-full"/></div><div class="flex items-end"><button class="btn btn-primary btn-sm w-full" data-action="doSearch">Search</button></div></div></div></div>`;
+}
+
+export function renderAdvancedSearch(user, results = {}, options = {}) {
+  const { teams = [], stages = [] } = options;
+  const allResults = [];
+  for (const [entityType, items] of Object.entries(results)) {
+    (items || []).forEach(item => allResults.push({ ...item, _type: entityType }));
+  }
+  allResults.sort((a, b) => (b.created_at || 0) - (a.created_at || 0));
+
+  const totalCount = allResults.length;
+  const entityCounts = {};
+  allResults.forEach(r => { entityCounts[r._type] = (entityCounts[r._type] || 0) + 1; });
+  const countBadges = Object.entries(entityCounts).map(([type, count]) => `<span class="badge badge-sm">${type}: ${count}</span>`).join(' ');
+
+  const resultCards = allResults.length > 0
+    ? allResults.map(r => resultCard(r, r._type)).join('')
+    : '<div class="text-center py-12 text-gray-400">Enter a search query to find engagements, clients, RFIs, and reviews</div>';
+
+  const content = `<div class="flex justify-between items-center mb-6"><h1 class="text-2xl font-bold">Advanced Search</h1></div>${filterPanel(teams, stages)}<div class="flex items-center gap-2 mb-4"><span class="text-sm text-gray-500">${totalCount} result${totalCount !== 1 ? 's' : ''}</span>${countBadges}</div><div id="search-results">${resultCards}</div>`;
+
+  const searchScript = `window.doSearch=async function(){const q=document.getElementById('search-query')?.value||'';const entity=document.getElementById('filter-entity')?.value||'';const status=document.getElementById('filter-status')?.value||'';const stage=document.getElementById('filter-stage')?.value||'';const team=document.getElementById('filter-team')?.value||'';const from=document.getElementById('filter-from')?.value||'';const to=document.getElementById('filter-to')?.value||'';const params=new URLSearchParams();if(q)params.set('q',q);if(entity)params.set('entity',entity);if(status)params.set('status',status);if(stage)params.set('stage',stage);if(team)params.set('team',team);if(from)params.set('from',from);if(to)params.set('to',to);window.location='/search?'+params.toString()};document.getElementById('search-query')?.addEventListener('keydown',function(e){if(e.key==='Enter')doSearch()})`;
+
+  return page(user, 'Search | Moonlanding', [{ href: '/', label: 'Dashboard' }, { label: 'Search' }], content, [searchScript]);
+}