thatcher 1.0.47 → 1.0.49

package/src/ui/calendar-view-renderer.js

@@ -0,0 +1,196 @@
+import { page } from '@/ui/layout.js';
+import { esc } from '@/ui/render-helpers.js';
+import { getEntityLabel } from '@/config/spec-helpers.js';
+
+const MONTH_NAMES = ['January','February','March','April','May','June','July','August','September','October','November','December'];
+const DAY_NAMES = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
+
+function calendarDateField(spec) {
+  if (spec.list?.dateField) return spec.list.dateField;
+  const entries = Object.entries(spec.fields || {});
+  const found = entries.find(([, f]) => f.type === 'date' || f.type === 'timestamp');
+  return found ? found[0] : null;
+}
+
+function toDateOrNull(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const num = Number(value);
+  if (!isNaN(num) && num > 0) return new Date(num * 1000);
+  const d = new Date(value);
+  return isNaN(d) ? null : d;
+}
+
+function dayKey(d) {
+  return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+}
+
+function calendarChip(entityName, record, titleField) {
+  const title = esc(record[titleField] ?? record.id);
+  return `<div class="calendar-chip" data-navigate="/${esc(entityName)}/${esc(record.id)}">${title}</div>`;
+}
+
+function calendarTitleField(spec) {
+  if (spec.list?.titleField) return spec.list.titleField;
+  const candidates = ['name', 'title', 'label'];
+  for (const c of candidates) if (spec.fields?.[c]) return c;
+  const first = Object.keys(spec.fields || {}).find(k => spec.fields[k]?.type === 'text');
+  return first || 'id';
+}
+
+export function renderCalendarView(user, entityName, spec, records, options = {}) {
+  const label = getEntityLabel(spec, true) || entityName;
+  const dateField = calendarDateField(spec);
+  const titleField = calendarTitleField(spec);
+
+  const now = new Date();
+  const year = Number(options.year) || now.getFullYear();
+  const month = options.month !== undefined ? Number(options.month) : now.getMonth();
+
+  const byDay = {};
+  const undated = [];
+
+  for (const r of records) {
+    const d = dateField ? toDateOrNull(r[dateField]) : null;
+    if (!d) { undated.push(r); continue; }
+    const key = dayKey(d);
+    if (!byDay[key]) byDay[key] = [];
+    byDay[key].push(r);
+  }
+
+  const firstOfMonth = new Date(year, month, 1);
+  const startWeekday = firstOfMonth.getDay();
+  const daysInMonth = new Date(year, month + 1, 0).getDate();
+
+  const cells = [];
+  for (let i = 0; i < startWeekday; i++) cells.push('<div class="calendar-cell calendar-cell-empty"></div>');
+  for (let day = 1; day <= daysInMonth; day++) {
+    const key = `${year}-${month}-${day}`;
+    const dayRecords = byDay[key] || [];
+    const chips = dayRecords.map(r => calendarChip(entityName, r, titleField)).join('');
+    const isToday = year === now.getFullYear() && month === now.getMonth() && day === now.getDate();
+    cells.push(`<div class="calendar-cell${isToday ? ' calendar-cell-today' : ''}">
+      <div class="calendar-cell-date">${day}</div>
+      <div class="calendar-cell-chips">${chips}</div>
+    </div>`);
+  }
+
+  const totalCells = startWeekday + daysInMonth;
+  const trailing = (7 - (totalCells % 7)) % 7;
+  for (let i = 0; i < trailing; i++) cells.push('<div class="calendar-cell calendar-cell-empty"></div>');
+
+  const dayHeaders = DAY_NAMES.map(d => `<div class="calendar-day-header">${d}</div>`).join('');
+
+  let prevMonth = month - 1, prevYear = year;
+  if (prevMonth < 0) { prevMonth = 11; prevYear -= 1; }
+  let nextMonth = month + 1, nextYear = year;
+  if (nextMonth > 11) { nextMonth = 0; nextYear += 1; }
+
+  const undatedSection = undated.length
+    ? `<div class="calendar-undated">
+        <h3>Undated (${undated.length})</h3>
+        <div class="calendar-undated-list">${undated.map(r => calendarChip(entityName, r, titleField)).join('')}</div>
+      </div>`
+    : '';
+
+  const noDateFieldNotice = !dateField
+    ? `<div class="calendar-empty-state">This entity has no date field configured; all records are shown as undated.</div>`
+    : '';
+
+  const content = `<div class="page-header">
+      <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+    </div>
+    ${noDateFieldNotice}
+    <div class="calendar-toolbar">
+      <a class="calendar-nav-link" href="?month=${prevMonth}&year=${prevYear}">&laquo; Prev</a>
+      <span class="calendar-month-label">${MONTH_NAMES[month]} ${year}</span>
+      <a class="calendar-nav-link" href="?month=${nextMonth}&year=${nextYear}">Next &raquo;</a>
+    </div>
+    <div class="calendar-grid">
+      ${dayHeaders}
+      ${cells.join('')}
+    </div>
+    ${undatedSection}`;
+
+  return page(user, `${label} | Calendar`, null, content);
+}
+
+function timelineFields(spec) {
+  if (spec.list?.timelineStart && spec.list?.timelineEnd) {
+    return [spec.list.timelineStart, spec.list.timelineEnd];
+  }
+  const fields = spec.fields || {};
+  const startCandidates = ['start_date', 'start'];
+  const endCandidates = ['end_date', 'due_date', 'end', 'deadline'];
+  const start = startCandidates.find(k => fields[k]) || null;
+  const end = endCandidates.find(k => fields[k]) || null;
+  return [start, end];
+}
+
+function timelineTitleField(spec) {
+  if (spec.list?.titleField) return spec.list.titleField;
+  const candidates = ['name', 'title', 'label'];
+  for (const c of candidates) if (spec.fields?.[c]) return c;
+  const first = Object.keys(spec.fields || {}).find(k => spec.fields[k]?.type === 'text');
+  return first || 'id';
+}
+
+export function renderTimelineView(user, entityName, spec, records, options = {}) {
+  const label = getEntityLabel(spec, true) || entityName;
+  const [startField, endField] = timelineFields(spec);
+  const titleField = timelineTitleField(spec);
+
+  const plotted = [];
+  let missing = 0;
+
+  for (const r of records) {
+    const start = startField ? toDateOrNull(r[startField]) : null;
+    const end = endField ? toDateOrNull(r[endField]) : null;
+    if (!start || !end) { missing++; continue; }
+    plotted.push({ record: r, start, end });
+  }
+
+  if (!startField || !endField) {
+    return page(user, `${label} | Timeline`, null,
+      `<div class="page-header">
+        <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+      </div>
+      <div class="timeline-empty-state">This entity has no start/end date fields configured; timeline view requires <code>list.timelineStart</code>/<code>list.timelineEnd</code> or matching field names.</div>`);
+  }
+
+  const missingNotice = missing
+    ? `<div class="timeline-missing-notice">${missing} item${missing === 1 ? '' : 's'} without dates not shown</div>`
+    : '';
+
+  if (!plotted.length) {
+    const content = `<div class="page-header">
+        <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+      </div>
+      ${missingNotice}
+      <div class="timeline-empty-state">No items have both a start and end date.</div>`;
+    return page(user, `${label} | Timeline`, null, content);
+  }
+
+  const minTime = Math.min(...plotted.map(p => p.start.getTime()));
+  const maxTime = Math.max(...plotted.map(p => p.end.getTime()));
+  const span = Math.max(1, maxTime - minTime);
+
+  const rows = plotted.map(({ record, start, end }) => {
+    const title = esc(record[titleField] ?? record.id);
+    const offsetPct = ((start.getTime() - minTime) / span) * 100;
+    const widthPct = Math.max(1, ((end.getTime() - start.getTime()) / span) * 100);
+    return `<div class="timeline-row">
+      <div class="timeline-row-label">${title}</div>
+      <div class="timeline-row-track">
+        <div class="timeline-bar" data-navigate="/${esc(entityName)}/${esc(record.id)}" style="margin-left:${offsetPct}%;width:${widthPct}%"></div>
+      </div>
+    </div>`;
+  }).join('');
+
+  const content = `<div class="page-header">
+      <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+    </div>
+    ${missingNotice}
+    <div class="timeline-view">${rows}</div>`;
+
+  return page(user, `${label} | Timeline`, null, content);
+}

package/src/ui/grid-view-renderer.js

@@ -0,0 +1,78 @@
+import { page } from '@/ui/layout.js';
+import { esc, fmtVal, TABLE_SCRIPT, emptyRow } from '@/ui/render-helpers.js';
+import { getDefaultSort, getAvailableFilters, getPageSize, getEntityLabel } from '@/config/spec-helpers.js';
+
+const EMBEDDED_TYPES = new Set(['json', 'embedded']);
+
+function getColumns(spec) {
+  const fields = spec?.fields || {};
+  const override = spec?.list?.columns;
+  if (Array.isArray(override) && override.length) {
+    return override
+      .filter(key => fields[key])
+      .map(key => [key, fields[key]]);
+  }
+  return Object.entries(fields).filter(([, f]) =>
+    !f.hidden && !EMBEDDED_TYPES.has(f.type)
+  );
+}
+
+function isEditable(field) {
+  return field && field.readonly !== true;
+}
+
+function gridRow(entityName, item, columns) {
+  const cells = columns.map(([key, field]) => {
+    const value = item[key];
+    const rendered = fmtVal(value, key, item);
+    const editableAttr = isEditable(field) ? ` data-editable="${esc(key)}"` : '';
+    return `<td data-col="${esc(key)}"${editableAttr}>${rendered}</td>`;
+  }).join('');
+  return `<tr data-row data-navigate="/${esc(entityName)}/${esc(item.id)}" style="cursor:pointer">${cells}</tr>`;
+}
+
+export function renderGridView(user, entityName, spec, records, options = {}) {
+  const label = getEntityLabel(spec, true) || entityName;
+  const columns = getColumns(spec);
+  const defaultSort = getDefaultSort(spec);
+  const filters = getAvailableFilters(spec);
+  const pageSize = getPageSize(spec);
+
+  const headerCells = columns.map(([key, field]) => {
+    const colLabel = esc(field?.label || key);
+    const isDefaultSort = key === defaultSort.field;
+    return `<th data-sort="${esc(key)}" aria-label="Sort by ${colLabel}"${isDefaultSort ? ` class="sort-${esc(defaultSort.dir)}"` : ''}>${colLabel}</th>`;
+  }).join('');
+
+  const filterControls = filters.map(f => {
+    const fieldKey = typeof f === 'string' ? f : f.field;
+    const fieldSpec = spec.fields?.[fieldKey];
+    const filterLabel = esc(fieldSpec?.label || fieldKey);
+    const opts = (fieldSpec?.options || f.options || []).map(o => {
+      const value = typeof o === 'string' ? o : o.value;
+      const optLabel = typeof o === 'string' ? o : (o.label || o.value);
+      return `<option value="${esc(value)}">${esc(optLabel)}</option>`;
+    }).join('');
+    return `<div class="table-filter"><select data-filter="${esc(fieldKey)}" id="filter-${esc(fieldKey)}" aria-label="Filter by ${filterLabel}"><option value="">All ${filterLabel}</option>${opts}</select></div>`;
+  }).join('');
+
+  const rows = records.map(item => gridRow(entityName, item, columns)).join('') ||
+    emptyRow(columns.length || 1, `No ${esc(label.toLowerCase())} found`);
+
+  const content = `<div class="page-header">
+        <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} total ${esc(label.toLowerCase())}</p></div>
+      </div>
+      <div class="table-wrap">
+        <div class="table-toolbar">
+          <div class="table-search"><input id="search-input" type="text" placeholder="Search ${esc(label.toLowerCase())}..."></div>
+          ${filterControls}
+          <span class="table-count" id="row-count">${records.length} items</span>
+        </div>
+        <table class="data-table" role="grid" data-page-size="${esc(pageSize)}">
+          <thead><tr>${headerCells}</tr></thead>
+          <tbody>${rows}</tbody>
+        </table>
+      </div>`;
+
+  return page(user, `${label} | Thatcher`, null, content, [TABLE_SCRIPT]);
+}

package/src/lib/compression.js

@@ -1,44 +0,0 @@
-import zlib from 'zlib';
-
-const COMPRESSION_THRESHOLD = 1024; // Only compress files >1KB
-
-export function compress(content, acceptEncoding = '') {
-  const size = Buffer.byteLength(content, 'utf-8');
-  if (size < COMPRESSION_THRESHOLD) return { content, encoding: null };
-  
-  const ae = acceptEncoding.toLowerCase();
-  
-  if (ae.includes('br')) {
-    const compressed = zlib.brotliCompressSync(content, {
-      params: {
-        [zlib.constants.BROTLI_PARAM_QUALITY]: 6,
-        [zlib.constants.BROTLI_PARAM_SIZE_HINT]: size
-      }
-    });
-    return { content: compressed, encoding: 'br' };
-  }
-  
-  if (ae.includes('gzip')) {
-    const compressed = zlib.gzipSync(content, { level: 6 });
-    return { content: compressed, encoding: 'gzip' };
-  }
-  
-  return { content, encoding: null };
-}
-
-export function getCacheHeaders(type, maxAge = 86400) {
-  if (type === 'static') {
-    return {
-      'Cache-Control': `public, max-age=${maxAge}, immutable`,
-      'Expires': new Date(Date.now() + maxAge * 1000).toUTCString()
-    };
-  }
-  if (type === 'dynamic') {
-    return {
-      'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
-      'Pragma': 'no-cache',
-      'Expires': '0'
-    };
-  }
-  return {};
-}

package/src/lib/route-resolver.js

@@ -1,160 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-export function resolveParamRoute(baseDir, segments) {
-  if (!fs.existsSync(baseDir)) return null;
-  if (segments.length === 0) {
-    const r = path.join(baseDir, 'route.js');
-    return fs.existsSync(r) ? r : null;
-  }
-  const [seg, ...rest] = segments;
-  const entries = fs.readdirSync(baseDir, { withFileTypes: true }).filter(e => e.isDirectory());
-  for (const entry of entries) {
-    const name = entry.name;
-    if (name === seg || name.startsWith('[')) {
-      const found = resolveParamRoute(path.join(baseDir, name), rest);
-      if (found) return found;
-    }
-  }
-  return null;
-}
-
-export function resolveSpecificParams(routeFile, pathParts) {
-  const result = {};
-  const routeRelative = routeFile.replace(/.*src\/app\/api\//, '').replace(/\/route\.js$/, '');
-  const routeSegments = routeRelative.split('/');
-  const urlSegments = pathParts.slice(0);
-  for (let i = 0; i < routeSegments.length && i < urlSegments.length; i++) {
-    const seg = routeSegments[i];
-    if (seg.startsWith('[') && seg.endsWith(']')) {
-      const paramName = seg.replace(/^\[\.\.\./, '').replace(/[[\]]/g, '');
-      result[paramName] = urlSegments[i];
-    }
-  }
-  return result;
-}
-
-function singularize(name) {
-  if (name.endsWith('ies')) return name.slice(0, -3) + 'y';
-  if (name.endsWith('ses') || name.endsWith('xes') || name.endsWith('zes')) return name.slice(0, -2);
-  if (name.endsWith('s') && !name.endsWith('ss')) return name.slice(0, -1);
-  return name;
-}
-
-export function buildNestedRoutePath(baseDir, domain, parentEntity, childParts) {
-  if (childParts.length === 0) return null;
-
-  function buildSegments(parentParam, childParamFn) {
-    const segs = [domain, parentEntity, parentParam];
-    for (let i = 0; i < childParts.length; i++) {
-      if (i % 2 === 0) segs.push(childParts[i]);
-      else segs.push(childParamFn(i));
-    }
-    return path.join(baseDir, 'src/app/api', ...segs, 'route.js');
-  }
-
-  const variants = [
-    () => buildSegments('[id]', (i) => `[${childParts[i - 1]}Id]`),
-    () => buildSegments('[id]', (i) => `[${singularize(childParts[i - 1])}Id]`),
-    () => buildSegments(`[${parentEntity}Id]`, (i) => `[${childParts[i - 1]}Id]`),
-    () => buildSegments(`[${parentEntity}Id]`, (i) => `[${singularize(childParts[i - 1])}Id]`),
-    () => buildSegments('[id]', () => `[${childParts[0]}Id]`),
-    () => buildSegments('[id]', () => `[${singularize(childParts[0])}Id]`),
-  ];
-
-  // Also try a "leaf-action" shape with no further id after the child segment.
-  // Routes like /mwr/review/[id]/export-pdf/route.js (parent + id + leaf action)
-  // were missed by the segment-pair variants above.
-  if (childParts.length === 1) {
-    const leaf = path.join(baseDir, 'src/app/api', domain, parentEntity, '[id]', childParts[0], 'route.js');
-    if (fs.existsSync(leaf)) return leaf;
-    const leafByEntity = path.join(baseDir, 'src/app/api', domain, parentEntity, `[${parentEntity}Id]`, childParts[0], 'route.js');
-    if (fs.existsSync(leafByEntity)) return leafByEntity;
-  }
-
-  for (const variant of variants) {
-    const candidate = variant();
-    if (fs.existsSync(candidate)) return candidate;
-  }
-  return variants[0]();
-}
-
-const DOMAINS = ['friday', 'mwr'];
-
-export function resolveRoute(__dirname, pathname, url) {
-  const pathParts = pathname.slice(5).split('/').filter(Boolean);
-
-  // Reject any '..' or '.' segment before it can reach a filesystem path
-  // join or a dynamic import -- otherwise a crafted URL can traverse out of
-  // src/app/api into arbitrary files on disk.
-  if (pathParts.some(seg => seg === '..' || seg === '.')) {
-    return { routeFile: null, params: {}, isDomain: false, firstPart: pathParts[0], pathParts };
-  }
-
-  const firstPart = pathParts[0];
-  const isDomain = DOMAINS.includes(firstPart);
-  let routeFile = null;
-  let params = {};
-
-  if (isDomain) {
-    const domain = firstPart;
-    const domainParts = pathParts.slice(1);
-
-    const specificCheck = path.join(__dirname, `src/app/api/${domain}/${domainParts.join('/')}/route.js`);
-    if (fs.existsSync(specificCheck)) {
-      routeFile = specificCheck;
-      params = resolveSpecificParams(specificCheck, pathParts);
-    }
-
-    if (!routeFile && domainParts.length >= 3) {
-      const parentEntity = domainParts[0];
-      const childParts = domainParts.slice(2);
-      const parentId = domainParts[1];
-      const childEntity = childParts[0];
-      const childId = childParts[1] || null;
-
-      const nestedSpecific = buildNestedRoutePath(__dirname, domain, parentEntity, childParts);
-      if (nestedSpecific && fs.existsSync(nestedSpecific)) {
-        routeFile = nestedSpecific;
-        params = resolveSpecificParams(nestedSpecific, pathParts);
-      }
-
-      if (!routeFile) {
-        routeFile = path.join(__dirname, 'src/app/api/[entity]/[[...path]]/route.js');
-        url.searchParams.set('domain', domain);
-        params = { entity: childEntity, path: childId ? [childId] : [], parentEntity, parentId };
-      }
-    }
-
-    if (!routeFile && domainParts.length >= 1) {
-      const entity = domainParts[0];
-      const entityPath = domainParts.slice(1);
-      routeFile = path.join(__dirname, 'src/app/api/[entity]/[[...path]]/route.js');
-      url.searchParams.set('domain', domain);
-      params = { entity, path: entityPath };
-    }
-  }
-
-  if (!routeFile && firstPart) {
-    const exactRoute = path.join(__dirname, `src/app/api/${pathParts.join('/')}/route.js`);
-    if (fs.existsSync(exactRoute)) {
-      routeFile = exactRoute;
-      params = resolveSpecificParams(exactRoute, pathParts);
-    }
-  }
-
-  if (!routeFile && firstPart) {
-    const paramRouteFile = resolveParamRoute(path.join(__dirname, 'src/app/api', firstPart), pathParts.slice(1));
-    if (paramRouteFile) {
-      routeFile = paramRouteFile;
-      params = resolveSpecificParams(paramRouteFile, pathParts);
-    }
-  }
-
-  if (!routeFile) {
-    routeFile = path.join(__dirname, 'src/app/api/[entity]/[[...path]]/route.js');
-    params = { entity: firstPart, path: pathParts.slice(1) };
-  }
-
-  return { routeFile, params, isDomain, firstPart, pathParts };
-}

package/src/lib/state-protocol.js

@@ -1,184 +0,0 @@
-// 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',
-  STATE_REQUEST: 'state_request',
-  STATE_ACK: 'state_ack',
-  STATE_NACK: 'state_nack',
-  PING: 'ping',
-  PONG: 'pong'
-}
-
-const ERROR_CODES = {
-  INVALID_MESSAGE: 'invalid_message',
-  INVALID_VERSION: 'invalid_version',
-  CONFLICT_DETECTED: 'conflict_detected',
-  RATE_LIMITED: 'rate_limited',
-  VALIDATION_FAILED: 'validation_failed'
-}
-
-class VectorClock {
-  constructor(nodeId) {
-    this.nodeId = nodeId
-    this.clock = { [nodeId]: 0 }
-  }
-
-  increment() {
-    this.clock[this.nodeId] = (this.clock[this.nodeId] || 0) + 1
-    return this.clock[this.nodeId]
-  }
-
-  update(otherClock) {
-    for (const [nodeId, timestamp] of Object.entries(otherClock)) {
-      this.clock[nodeId] = Math.max(this.clock[nodeId] || 0, timestamp)
-    }
-  }
-
-  compare(otherClock) {
-    const keys = new Set([...Object.keys(this.clock), ...Object.keys(otherClock)])
-    let hasGreater = false
-    let hasLess = false
-
-    for (const key of keys) {
-      const mine = this.clock[key] || 0
-      const theirs = otherClock[key] || 0
-      if (mine > theirs) hasGreater = true
-      if (mine < theirs) hasLess = true
-    }
-
-    if (hasGreater && !hasLess) return 1
-    if (hasLess && !hasGreater) return -1
-    if (!hasGreater && !hasLess) return 0
-    return null // Concurrent
-  }
-
-  serialize() {
-    return { ...this.clock }
-  }
-
-  static deserialize(data, nodeId) {
-    const vc = new VectorClock(nodeId)
-    vc.clock = { ...data }
-    return vc
-  }
-}
-
-const MessageSchema = {
-  validate(message) {
-    if (!message || typeof message !== 'object') {
-      return { valid: false, error: 'Message must be an object' }
-    }
-    const validTypes = Object.values(MESSAGE_TYPES)
-    if (!validTypes.includes(message.type)) {
-      return { valid: false, error: 'Invalid message type' }
-    }
-    if (message.type !== MESSAGE_TYPES.PING && message.type !== MESSAGE_TYPES.PONG) {
-      if (!message.version || typeof message.version !== 'object') {
-        return { valid: false, error: 'Missing or invalid version vector' }
-      }
-    }
-    if (message.type === MESSAGE_TYPES.STATE_UPDATE || message.type === MESSAGE_TYPES.STATE_SNAPSHOT) {
-      if (message.data === undefined) {
-        return { valid: false, error: 'Missing data field' }
-      }
-    }
-    return { valid: true }
-  }
-}
-
-function createMessage(type, payload = {}) {
-  return {
-    type,
-    timestamp: Date.now(),
-    ...payload
-  }
-}
-
-function createStateUpdate(vectorClock, data, operations = []) {
-  return createMessage(MESSAGE_TYPES.STATE_UPDATE, {
-    version: vectorClock.serialize(),
-    data,
-    operations
-  })
-}
-
-function createStateSnapshot(vectorClock, data) {
-  return createMessage(MESSAGE_TYPES.STATE_SNAPSHOT, {
-    version: vectorClock.serialize(),
-    data
-  })
-}
-
-function createStateRequest(vectorClock) {
-  return createMessage(MESSAGE_TYPES.STATE_REQUEST, {
-    version: vectorClock.serialize()
-  })
-}
-
-function createStateAck(messageId, vectorClock) {
-  return createMessage(MESSAGE_TYPES.STATE_ACK, {
-    messageId,
-    version: vectorClock.serialize()
-  })
-}
-
-function createStateNack(messageId, error, errorCode) {
-  return createMessage(MESSAGE_TYPES.STATE_NACK, {
-    messageId,
-    error,
-    errorCode
-  })
-}
-
-function createPing() {
-  return createMessage(MESSAGE_TYPES.PING)
-}
-
-function createPong(pingTimestamp) {
-  return createMessage(MESSAGE_TYPES.PONG, { pingTimestamp })
-}
-
-const Protocol = {
-  MESSAGE_TYPES,
-  ERROR_CODES,
-  VectorClock,
-  MessageSchema,
-  createMessage,
-  createStateUpdate,
-  createStateSnapshot,
-  createStateRequest,
-  createStateAck,
-  createStateNack,
-  createPing,
-  createPong
-}
-
-export {
-  MESSAGE_TYPES,
-  ERROR_CODES,
-  VectorClock,
-  MessageSchema,
-  createMessage,
-  createStateUpdate,
-  createStateSnapshot,
-  createStateRequest,
-  createStateAck,
-  createStateNack,
-  createPing,
-  createPong,
-  Protocol
-}
-
-export default Protocol