@fdcn/sourcefed 0.2.0

package/dist/core-storage.js

@@ -0,0 +1,13 @@
+import {
+  InMemoryMonitorStore,
+  JsonMonitorEventQueue,
+  JsonMonitorStore,
+  defaultJsonMonitorStore
+} from "./chunk-NGJ6F5ST.js";
+import "./chunk-MLKGABMK.js";
+export {
+  InMemoryMonitorStore,
+  JsonMonitorEventQueue,
+  JsonMonitorStore,
+  defaultJsonMonitorStore
+};

package/dist/core.js

@@ -0,0 +1,643 @@
+import {
+  InMemoryMonitorEventQueue,
+  InMemoryMonitorStore,
+  JsonMonitorEventQueue,
+  JsonMonitorStore,
+  MonitorRecordSchema,
+  MonitorRegistrySchema,
+  QueueMonitorEventSink,
+  array,
+  boolean,
+  createQueuedMonitorEvent,
+  defaultJsonMonitorStore,
+  monitorEventID,
+  object,
+  optional,
+  safeParse,
+  string,
+  unknown
+} from "./chunk-NGJ6F5ST.js";
+import "./chunk-MLKGABMK.js";
+
+// packages/core/src/monitors/monitor.ts
+var Monitor = class {
+  type;
+  schema;
+  poll;
+  webhook;
+  constructor(options) {
+    this.type = options.type;
+    this.schema = options.schema;
+  }
+  validateSource(source) {
+    const result = safeParse(this.schema, source);
+    if (result.success) return result.output;
+    throw new Error(`invalid ${this.type} monitor source`);
+  }
+  initialDelivery(source) {
+    this.validateSource(source);
+    if (this.webhook && this.webhook.preferred && this.webhook.configured()) return "webhook";
+    if (this.poll) return "poll";
+    if (this.webhook) return "webhook";
+    throw new Error(`source ${this.type} has no configured transport`);
+  }
+  resolveDelivery(monitor) {
+    let webhookHealthy = false;
+    if (this.webhook) webhookHealthy = this.webhook.isHealthy(monitor);
+    if (monitor.delivery === "webhook") {
+      if (this.webhook && webhookHealthy) return "webhook";
+      if (this.poll) return "poll";
+      if (this.webhook) return "webhook";
+      return void 0;
+    }
+    if (this.webhook && webhookHealthy) return "webhook";
+    if (this.poll) return "poll";
+    if (this.webhook) return "webhook";
+    return void 0;
+  }
+  async tick(context, record) {
+    const fresh = await context.service.get(record.id);
+    if (!fresh || !fresh.enabled) return 0;
+    if (this.webhook) await this.webhook.retryPending(context, this, fresh);
+    const current = await context.service.get(record.id);
+    if (!current || !current.enabled) return 0;
+    const nextDelivery = this.resolveDelivery(current);
+    if (!nextDelivery) return 0;
+    if (nextDelivery !== current.delivery) {
+      await context.service.setDelivery(current.id, nextDelivery);
+      current.delivery = nextDelivery;
+    }
+    if (current.delivery !== "poll" || !this.poll) return 0;
+    const lastAttemptAt = Number(current.cursors.__lastAttemptAt ?? current.cursors.__lastPolledAt ?? 0);
+    const pollIntervalSec = current.pollIntervalSec || 60;
+    if (lastAttemptAt && Date.now() - lastAttemptAt < pollIntervalSec * 1e3) return 0;
+    return this.poll.run(context, this, current);
+  }
+  async deliver(context, record, event, deliveryId) {
+    if (!this.webhook) return 0;
+    return this.webhook.deliver(context, this, record, event, deliveryId);
+  }
+  unresponsive(record, now = Date.now()) {
+    if (!record.enabled) return false;
+    if (record.delivery === "poll") {
+      if (!this.poll) return true;
+      return this.poll.isUnresponsive(record, now);
+    }
+    if (!this.webhook) return true;
+    return this.webhook.isUnresponsive(record, now);
+  }
+};
+
+// packages/core/src/monitors/utils/monitor-identity.ts
+function monitorSourceIdentity(source) {
+  return JSON.stringify(stableValue(source));
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableValue(entry)])
+  );
+}
+function monitorIdentity(target, source) {
+  return JSON.stringify([target.kind, target.id, monitorSourceIdentity(source)]);
+}
+function dedupeActiveMonitors(monitors) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const monitor of monitors) {
+    if (!monitor.enabled) {
+      result.push(monitor);
+      continue;
+    }
+    const identity = monitorIdentity(monitor.target, monitor.source);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    result.push(monitor);
+  }
+  return result;
+}
+
+// packages/core/src/monitors/service.ts
+var MonitorService = class {
+  constructor(store) {
+    this.store = store;
+  }
+  registryQueue = Promise.resolve();
+  async list() {
+    return (await this.store.load()).monitors;
+  }
+  async get(id) {
+    return (await this.store.load()).monitors.find((monitor) => monitor.id === id);
+  }
+  async create(input) {
+    return this.transact((registry) => {
+      registry.monitors = dedupeActiveMonitors(registry.monitors);
+      const identity = monitorIdentity(input.target, input.source);
+      const existing = registry.monitors.find(
+        (monitor2) => monitor2.enabled && monitorIdentity(monitor2.target, monitor2.source) === identity
+      );
+      if (existing) return { monitor: existing, created: false };
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const monitor = {
+        id: `m-${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 6)}`,
+        name: input.name,
+        source: input.source,
+        delivery: input.delivery,
+        target: input.target,
+        pollIntervalSec: Math.max(15, input.pollIntervalSec ?? 60),
+        enabled: true,
+        createdAt: now,
+        updatedAt: now,
+        cursors: {}
+      };
+      registry.monitors.push(monitor);
+      return { monitor, created: true };
+    });
+  }
+  async stop(id) {
+    return this.transact((registry) => {
+      const monitor = registry.monitors.find((entry) => entry.id === id);
+      if (!monitor) return { error: `monitor ${id} was not found` };
+      monitor.enabled = false;
+      monitor.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return monitor;
+    });
+  }
+  async start(id) {
+    return this.transact((registry) => {
+      const monitor = registry.monitors.find((entry) => entry.id === id);
+      if (!monitor) return { error: `monitor ${id} was not found` };
+      monitor.enabled = true;
+      monitor.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return monitor;
+    });
+  }
+  async remove(id) {
+    await this.transact((registry) => {
+      registry.monitors = registry.monitors.filter((monitor) => monitor.id !== id);
+    });
+  }
+  async setDelivery(id, delivery) {
+    await this.updateMonitor(id, (monitor) => {
+      monitor.delivery = delivery;
+    });
+  }
+  async updateCursor(monitor, key, value) {
+    await this.updateMonitor(monitor.id, (current) => {
+      current.cursors[key] = value;
+    });
+  }
+  async updateCursorValue(monitor, key, update) {
+    await this.updateMonitor(monitor.id, (current) => {
+      current.cursors[key] = update(current.cursors[key]);
+    });
+  }
+  async dedupe() {
+    return this.transact((registry) => {
+      const deduped = dedupeActiveMonitors(registry.monitors);
+      const removed = registry.monitors.length - deduped.length;
+      registry.monitors = deduped;
+      return removed;
+    });
+  }
+  async updateMonitor(id, update) {
+    await this.transact((registry) => {
+      const monitor = registry.monitors.find((entry) => entry.id === id);
+      if (!monitor) return;
+      update(monitor);
+      monitor.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
+  }
+  transact(operation) {
+    const next = this.registryQueue.then(async () => {
+      const registry = await this.store.load();
+      const result = await operation(registry);
+      await this.store.save(registry);
+      return result;
+    });
+    this.registryQueue = next.then(() => void 0, () => void 0);
+    return next;
+  }
+};
+
+// packages/core/src/monitors/poll/types/routed-event-cursor.ts
+var RoutedEventCursorSchema = array(string());
+
+// packages/core/src/monitors/poll/utils/event-delivery-id.ts
+function eventDeliveryId(event) {
+  if (event.id) return event.id;
+  return `${event.kind}:${event.at}:${event.summary}`;
+}
+
+// packages/core/src/monitors/poll/monitor.ts
+var activePolls = /* @__PURE__ */ new Set();
+var PollMonitor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async run(context, source, record) {
+    if (activePolls.has(record.id)) return 0;
+    activePolls.add(record.id);
+    try {
+      const fresh = await context.service.get(record.id);
+      if (!fresh) return 0;
+      const sourceRecord = source.validateSource(fresh.source);
+      const cursorKey = source.key(sourceRecord);
+      const result = await this.options.run(sourceRecord, fresh.cursors[cursorKey]);
+      const current = await context.service.get(record.id);
+      if (!current || !current.enabled) return 0;
+      const parsedRoutedIds = safeParse(RoutedEventCursorSchema, fresh.cursors.__routedEventIds);
+      let routedIds = [];
+      if (parsedRoutedIds.success) routedIds = parsedRoutedIds.output;
+      let routeFailed = false;
+      for (const event of result.events) {
+        const eventId = eventDeliveryId(event);
+        if (routedIds.includes(eventId)) continue;
+        const routed = await context.sink.deliver({ monitor: fresh, event });
+        if (!routed.ok) {
+          routeFailed = true;
+          console.error(`[sourcefed] route failed for ${fresh.id}: ${routed.error}`);
+          continue;
+        }
+        if (!routedIds.includes(eventId)) routedIds.push(eventId);
+      }
+      if (routeFailed) {
+        await context.service.updateCursor(fresh, "__routedEventIds", routedIds);
+        return 0;
+      }
+      await context.service.updateCursorValue(fresh, cursorKey, (current2) => {
+        if (this.options.mergeCursor) return this.options.mergeCursor(current2, result.cursor);
+        return result.cursor;
+      });
+      await context.service.updateCursor(fresh, "__routedEventIds", []);
+      if (result.terminal) await context.service.remove(fresh.id);
+      await context.service.updateCursor(fresh, "__lastPolledAt", Date.now());
+      return result.events.length;
+    } finally {
+      activePolls.delete(record.id);
+    }
+  }
+  isUnresponsive(record, now) {
+    const intervalMs = Math.max((record.pollIntervalSec || 60) * 3e3, 12e4);
+    const lastPolledAt = Number(record.cursors.__lastPolledAt ?? 0);
+    if (lastPolledAt > 0) return now - lastPolledAt > intervalMs;
+    return now - Date.parse(record.createdAt) > intervalMs;
+  }
+};
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeCursors(current, result) {
+  if (Array.isArray(current) && Array.isArray(result)) {
+    return [.../* @__PURE__ */ new Set([...current, ...result])];
+  }
+  if (isRecord(current) && isRecord(result)) {
+    const merged = { ...current };
+    for (const [key, value] of Object.entries(result)) {
+      if (value === void 0) continue;
+      merged[key] = key in current ? mergeCursors(current[key], value) : value;
+    }
+    return merged;
+  }
+  return result === void 0 ? current : result;
+}
+
+// packages/core/src/monitors/webhook/utils/constants.ts
+var WEBHOOK_STALE_MS = 9e4;
+var WEBHOOK_STARTUP_GRACE_MS = 12e4;
+
+// packages/core/src/monitors/webhook/types/pending-webhook-event.ts
+var PendingWebhookEventSchema = object({
+  deliveryId: string(),
+  event: object({
+    source: unknown(),
+    kind: string(),
+    id: optional(string()),
+    at: string(),
+    summary: string(),
+    body: optional(string()),
+    actionable: boolean(),
+    terminal: optional(boolean())
+  })
+});
+var PendingWebhookEventsSchema = array(PendingWebhookEventSchema);
+
+// packages/core/src/monitors/webhook/monitor.ts
+var pendingDeliveries = /* @__PURE__ */ new Set();
+var PENDING_WEBHOOK_EVENTS = "__pendingWebhookEvents";
+var WebhookMonitor = class {
+  path;
+  preferred;
+  configured;
+  verify;
+  acknowledgeBeforeDelivery;
+  challenge;
+  deliveryId;
+  eventName;
+  parse;
+  updateCursor;
+  constructor(options) {
+    this.path = options.path;
+    this.preferred = options.preferred ?? true;
+    this.configured = options.configured;
+    this.verify = options.verify;
+    this.acknowledgeBeforeDelivery = options.acknowledgeBeforeDelivery ?? false;
+    this.challenge = options.challenge;
+    this.deliveryId = options.deliveryId;
+    this.eventName = options.eventName;
+    this.parse = options.parse;
+    this.updateCursor = options.updateCursor;
+  }
+  isHealthy(record) {
+    if (!this.preferred || !this.configured()) return false;
+    const heartbeatAt = Number(record.cursors.__webhookHeartbeatAt ?? 0);
+    if (heartbeatAt > 0) return Date.now() - heartbeatAt <= WEBHOOK_STALE_MS;
+    return Date.now() - Date.parse(record.createdAt) <= WEBHOOK_STARTUP_GRACE_MS;
+  }
+  isUnresponsive(record, now) {
+    const heartbeatAt = Number(record.cursors.__webhookHeartbeatAt ?? 0);
+    if (heartbeatAt > 0) return now - heartbeatAt > WEBHOOK_STALE_MS;
+    return now - Date.parse(record.createdAt) > WEBHOOK_STARTUP_GRACE_MS;
+  }
+  async retryPending(context, source, record) {
+    const fresh = await context.service.get(record.id);
+    if (!fresh || !fresh.enabled) return 0;
+    const parsed = safeParse(PendingWebhookEventsSchema, fresh.cursors[PENDING_WEBHOOK_EVENTS]);
+    if (!parsed.success) return 0;
+    let delivered = 0;
+    for (const pending of parsed.output) {
+      const current = await context.service.get(record.id);
+      if (!current || !current.enabled) break;
+      const cursorKey = `webhook:${pending.deliveryId}`;
+      if (current.cursors[cursorKey]) {
+        await this.removePending(context, current, pending.deliveryId);
+        continue;
+      }
+      delivered += await this.deliver(context, source, current, pending.event, pending.deliveryId);
+    }
+    return delivered;
+  }
+  async addPending(context, monitor, deliveryId, event) {
+    await context.service.updateCursorValue(monitor, PENDING_WEBHOOK_EVENTS, (cursor) => {
+      const parsed = safeParse(PendingWebhookEventsSchema, cursor);
+      let pending = [];
+      if (parsed.success) pending = parsed.output;
+      if (pending.some((entry) => entry.deliveryId === deliveryId)) return pending;
+      pending.push({ deliveryId, event });
+      return pending;
+    });
+  }
+  async removePending(context, monitor, deliveryId) {
+    await context.service.updateCursorValue(monitor, PENDING_WEBHOOK_EVENTS, (cursor) => {
+      const parsed = safeParse(PendingWebhookEventsSchema, cursor);
+      if (!parsed.success) return [];
+      return parsed.output.filter((entry) => entry.deliveryId !== deliveryId);
+    });
+  }
+  async deliver(context, source, record, event, deliveryId) {
+    const fresh = await context.service.get(record.id);
+    if (!fresh || !fresh.enabled) return 0;
+    const freshSource = source.validateSource(fresh.source);
+    const eventSource = source.validateSource(event.source);
+    if (source.key(freshSource) !== source.key(eventSource)) return 0;
+    if (event.kind === "ci" && !event.actionable) return 0;
+    const cursorKey = `webhook:${deliveryId}`;
+    const reservationKey = `${fresh.id}:${deliveryId}`;
+    if (pendingDeliveries.has(reservationKey)) return 0;
+    if (fresh.cursors[cursorKey]) {
+      await this.removePending(context, fresh, deliveryId);
+      return 0;
+    }
+    pendingDeliveries.add(reservationKey);
+    try {
+      await this.addPending(context, fresh, deliveryId, event);
+      if (this.updateCursor) {
+        const sourceCursorKey = source.key(freshSource);
+        await context.service.updateCursorValue(fresh, sourceCursorKey, (cursor) => this.updateCursor(event, cursor));
+      }
+      const result = await context.sink.deliver({ monitor: fresh, event });
+      if (!result.ok) {
+        console.error(`[sourcefed] webhook route failed for ${fresh.id}: ${result.error}`);
+        return 0;
+      }
+      await context.service.setDelivery(fresh.id, "webhook");
+      await context.service.updateCursor(fresh, cursorKey, true);
+      await this.removePending(context, fresh, deliveryId);
+      if (event.terminal) await context.service.remove(fresh.id);
+      return 1;
+    } finally {
+      pendingDeliveries.delete(reservationKey);
+    }
+  }
+};
+
+// packages/core/src/monitors/poll/utils/tick.ts
+async function tick(context) {
+  const monitors = await context.service.list();
+  for (const record of monitors) {
+    if (!record.enabled) continue;
+    const source = context.sources[record.source.type];
+    if (!source) {
+      console.error(`[sourcefed] no monitor provider for source type ${record.source.type}`);
+      continue;
+    }
+    try {
+      await source.tick(context, record);
+    } catch (error) {
+      console.error(`[sourcefed] monitor ${record.id} poll failed:`, error);
+      await context.service.updateCursor(record, "__lastAttemptAt", Date.now()).catch((updateError) => {
+        console.error(`[sourcefed] monitor ${record.id} poll timestamp update failed:`, updateError);
+      });
+    }
+  }
+}
+
+// packages/core/src/monitors/webhook/utils/deliver-webhook.ts
+async function deliverWebhook(context, source, event, deliveryId) {
+  let delivered = 0;
+  const monitors = await context.service.list();
+  for (const monitor of monitors) {
+    const monitorSource = context.sources[monitor.source.type];
+    if (!monitorSource) continue;
+    if (monitorSource.type !== source.type) continue;
+    delivered += await monitorSource.deliver(context, monitor, event, deliveryId);
+  }
+  return delivered;
+}
+
+// packages/core/src/monitors/webhook/utils/heartbeat-webhooks.ts
+async function heartbeatWebhooks(context, source, eventSource) {
+  const sourceKey = source.key(source.validateSource(eventSource));
+  const monitors = await context.service.list();
+  for (const monitor of monitors) {
+    if (!monitor.enabled || monitor.source.type !== source.type) continue;
+    if (source.key(source.validateSource(monitor.source)) !== sourceKey) continue;
+    await context.service.updateCursor(monitor, "__webhookHeartbeatAt", Date.now());
+  }
+}
+
+// packages/core/src/monitors/webhook/utils/handle-webhook.ts
+var MAX_WEBHOOK_BODY_BYTES = 1024 * 1024;
+async function handleWebhook(request, context) {
+  const source = context.sourceForWebhookPath(new URL(request.url).pathname);
+  if (!source || !source.webhook) return new Response("not found", { status: 404 });
+  const body = await readBody(request);
+  if (body === void 0) return new Response("payload too large", { status: 413 });
+  if (!source.webhook.verify(body, request)) return new Response("invalid signature", { status: 401 });
+  let payload;
+  try {
+    payload = JSON.parse(body);
+  } catch {
+    return new Response("invalid json", { status: 400 });
+  }
+  const challenge = source.webhook.challenge?.(payload);
+  if (challenge) return Response.json(challenge);
+  const deliveryId = source.webhook.deliveryId(request, payload);
+  if (!deliveryId) return new Response("missing delivery id", { status: 400 });
+  const eventName = source.webhook.eventName(request, payload);
+  const event = source.webhook.parse(payload, eventName, deliveryId);
+  if (!event) return new Response("ignored", { status: 202 });
+  void heartbeatWebhooks(context, source, event.source).catch((error) => console.error("[sourcefed] webhook heartbeat failed:", error));
+  if (source.webhook.acknowledgeBeforeDelivery) {
+    void deliverWebhook(context, source, event, deliveryId).catch((error) => console.error("[sourcefed] webhook delivery failed:", error));
+    return new Response("accepted", { status: 202 });
+  }
+  await deliverWebhook(context, source, event, deliveryId);
+  return new Response("ok");
+}
+async function readBody(request) {
+  const contentLength = Number(request.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > MAX_WEBHOOK_BODY_BYTES) return void 0;
+  const reader = request.body?.getReader();
+  if (!reader) return "";
+  const chunks = [];
+  let length = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      if (length > MAX_WEBHOOK_BODY_BYTES) {
+        await reader.cancel();
+        return void 0;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+// packages/core/src/runtime.ts
+var MonitorRuntime = class {
+  service;
+  context;
+  timer;
+  activeTicks = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.service = new MonitorService(options.store);
+    this.context = {
+      service: this.service,
+      sink: options.sink,
+      sources: options.sources,
+      sourceForWebhookPath: options.sourceForWebhookPath
+    };
+    this.pollLoopSec = Math.max(1, options.pollLoopSec ?? 5);
+  }
+  pollLoopSec;
+  async start() {
+    await this.service.dedupe();
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      const tick2 = this.tick().catch((error) => console.error("[sourcefed] monitor tick error:", error));
+      this.activeTicks.add(tick2);
+      void tick2.finally(() => this.activeTicks.delete(tick2));
+    }, this.pollLoopSec * 1e3);
+    const initial = this.tick().catch((error) => console.error("[sourcefed] monitor tick error:", error));
+    this.activeTicks.add(initial);
+    void initial.finally(() => this.activeTicks.delete(initial));
+  }
+  async tick() {
+    await tick(this.context);
+  }
+  async webhook(request) {
+    return handleWebhook(request, this.context);
+  }
+  async stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    const ticks = [...this.activeTicks];
+    if (ticks.length === 0) return true;
+    let timer;
+    const settled = await Promise.race([
+      Promise.allSettled(ticks).then(() => true),
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          console.warn("[sourcefed] stop waited 30s for in-flight monitor ticks; retaining state lock");
+          resolve(false);
+        }, 3e4);
+      })
+    ]);
+    if (timer) clearTimeout(timer);
+    return settled;
+  }
+};
+
+// packages/core/src/utils/event-to-text.ts
+function eventToText(event) {
+  const summary = event.summary.trim();
+  let detail = "";
+  if (event.kind !== "merged" && event.body) detail = event.body.trim();
+  let duplicateDetail = detail;
+  if (detail && summary.includes(detail)) duplicateDetail = "";
+  const lines = [`[sourcefed monitor] ${summary}`];
+  if (duplicateDetail) lines.push(`
+${duplicateDetail}`);
+  return lines.filter(Boolean).join("\n");
+}
+
+// packages/core/src/utils/to-monitor-event.ts
+function toMonitorEvent(event, source) {
+  return {
+    source,
+    kind: event.kind,
+    id: event.id,
+    at: event.at,
+    summary: event.summary,
+    body: event.body,
+    actionable: event.actionable,
+    terminal: event.terminal
+  };
+}
+export {
+  InMemoryMonitorEventQueue,
+  InMemoryMonitorStore,
+  JsonMonitorEventQueue,
+  JsonMonitorStore,
+  Monitor,
+  MonitorRecordSchema,
+  MonitorRegistrySchema,
+  MonitorRuntime,
+  MonitorService,
+  PollMonitor,
+  QueueMonitorEventSink,
+  WebhookMonitor,
+  createQueuedMonitorEvent,
+  dedupeActiveMonitors,
+  defaultJsonMonitorStore,
+  eventToText,
+  mergeCursors,
+  monitorEventID,
+  monitorIdentity,
+  toMonitorEvent
+};