@fdcn/sourcefed 0.3.2 → 0.3.4

package/dist/chunk-BNLZQKEB.js

@@ -0,0 +1,962 @@
+// packages/core/dist/index.js
+import { link, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var store$4;
+var DEFAULT_CONFIG = {
+  lang: void 0,
+  message: void 0,
+  abortEarly: void 0,
+  abortPipeEarly: void 0
+};
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4) return DEFAULT_CONFIG;
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema) dataset.typed = false;
+  if (dataset.issues) dataset.issues.push(issue);
+  else dataset.issues = [issue];
+}
+var _standardCache = /* @__PURE__ */ new WeakMap();
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  let cached = _standardCache.get(context);
+  if (!cached) {
+    cached = {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+    _standardCache.set(context, cached);
+  }
+  return cached;
+}
+// @__NO_SIDE_EFFECTS__
+function _isValidObjectKey(object$1, key) {
+  return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+  return list[0] ?? "never";
+}
+var EMOJI_REGEX = new RegExp("^(?:[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation}))*)+$", "u");
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message$1) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value$1
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = itemDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) dataset.typed = false;
+          dataset.value.push(itemDataset.value);
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message$1) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "boolean") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _merge(value1, value2) {
+  if (typeof value1 === typeof value2) {
+    if (value1 === value2 || value1 instanceof Date && value2 instanceof Date && +value1 === +value2) return { value: value1 };
+    if (value1 && value2 && value1.constructor === Object && value2.constructor === Object) {
+      const nextValue = { ...value1 };
+      for (const key in value2) if (Object.prototype.hasOwnProperty.call(value1, key)) {
+        const dataset = /* @__PURE__ */ _merge(value1[key], value2[key]);
+        if (dataset.issue) return dataset;
+        nextValue[key] = dataset.value;
+      } else nextValue[key] = value2[key];
+      return { value: nextValue };
+    }
+    if (Array.isArray(value1) && Array.isArray(value2)) {
+      if (value1.length === value2.length) {
+        const nextValue = [...value1];
+        for (let index = 0; index < value1.length; index++) {
+          const dataset = /* @__PURE__ */ _merge(value1[index], value2[index]);
+          if (dataset.issue) return dataset;
+          nextValue[index] = dataset.value;
+        }
+        return { value: nextValue };
+      }
+    }
+  }
+  return { issue: true };
+}
+// @__NO_SIDE_EFFECTS__
+function intersect(options, message$1) {
+  return {
+    kind: "schema",
+    type: "intersect",
+    reference: intersect,
+    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "&"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.options.length) {
+        const input = dataset.value;
+        let outputs;
+        dataset.typed = true;
+        for (const schema of this.options) {
+          const optionDataset = schema["~run"]({ value: input }, config$1);
+          if (optionDataset.issues) {
+            if (dataset.issues) for (const issue of optionDataset.issues) dataset.issues.push(issue);
+            else dataset.issues = optionDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!optionDataset.typed) dataset.typed = false;
+          if (dataset.typed) if (outputs) outputs.push(optionDataset.value);
+          else outputs = [optionDataset.value];
+        }
+        if (dataset.typed) {
+          dataset.value = outputs[0];
+          for (let index = 1; index < outputs.length; index++) {
+            const mergeDataset = /* @__PURE__ */ _merge(dataset.value, outputs[index]);
+            if (mergeDataset.issue) {
+              _addIssue(this, "type", dataset, config$1, { received: "unknown" });
+              break;
+            }
+            dataset.value = mergeDataset.value;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message$1) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function picklist(options, message$1) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.options.includes(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function record(key, value$1, message$1) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+          const entryValue = input[entryKey];
+          const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+          if (keyDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "key",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of keyDataset.issues) {
+              issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = keyDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+          if (valueDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "value",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of valueDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = valueDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+          if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function unknown() {
+  return {
+    kind: "schema",
+    type: "unknown",
+    reference: unknown,
+    expects: "unknown",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+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;
+}
+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` };
+      const identity = monitorIdentity(monitor.target, monitor.source);
+      const duplicate = registry.monitors.find(
+        (entry) => entry.id !== id && entry.enabled && monitorIdentity(entry.target, entry.source) === identity
+      );
+      if (duplicate) return { error: `monitor ${id} duplicates active monitor ${duplicate.id} for the same source` };
+      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;
+  }
+};
+async function tick(context) {
+  const monitors = await context.service.list();
+  for (const record2 of monitors) {
+    if (!record2.enabled) continue;
+    const source = context.sources[record2.source.type];
+    if (!source) {
+      console.error(`[sourcefed] no monitor provider for source type ${record2.source.type}`);
+      continue;
+    }
+    try {
+      await source.tick(context, record2);
+    } catch (error) {
+      console.error(`[sourcefed] monitor ${record2.id} poll failed:`, error);
+      await context.service.updateCursor(record2, "__lastAttemptAt", Date.now()).catch((updateError) => {
+        console.error(`[sourcefed] monitor ${record2.id} poll timestamp update failed:`, updateError);
+      });
+    }
+  }
+}
+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;
+}
+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());
+  }
+}
+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);
+}
+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;
+  }
+};
+function createQueuedMonitorEvent(monitor, event) {
+  return {
+    id: `${monitor.id}:${monitorEventID(event)}`,
+    monitorID: monitor.id,
+    target: monitor.target,
+    event,
+    queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function monitorEventID(event) {
+  if (event.id) return event.id;
+  return `${event.kind}:${event.at}:${event.summary}`;
+}
+var MonitorSourceSchema = /* @__PURE__ */ intersect([
+  /* @__PURE__ */ object({ type: /* @__PURE__ */ string() }),
+  /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ unknown())
+]);
+var MonitorRecordSchema = /* @__PURE__ */ object({
+  id: /* @__PURE__ */ string(),
+  name: /* @__PURE__ */ string(),
+  source: MonitorSourceSchema,
+  delivery: /* @__PURE__ */ picklist(["poll", "webhook"]),
+  target: /* @__PURE__ */ object({
+    kind: /* @__PURE__ */ string(),
+    id: /* @__PURE__ */ string()
+  }),
+  pollIntervalSec: /* @__PURE__ */ number(),
+  enabled: /* @__PURE__ */ boolean(),
+  createdAt: /* @__PURE__ */ string(),
+  updatedAt: /* @__PURE__ */ string(),
+  cursors: /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ unknown())
+});
+var MonitorRegistrySchema = /* @__PURE__ */ object({
+  monitors: /* @__PURE__ */ array(MonitorRecordSchema)
+});
+var JsonMonitorStore = class {
+  stateDir;
+  stateFile;
+  constructor(options = {}) {
+    this.stateDir = options.stateDir ?? process.env.SOURCEFED_STATE_DIR ?? path.join(process.env.XDG_STATE_HOME ?? path.join(os.homedir(), ".local", "state"), "sourcefed");
+    this.stateFile = path.join(this.stateDir, "monitors.json");
+  }
+  async load() {
+    const raw = await this.readRaw(this.stateFile);
+    if (raw === void 0) return { monitors: [] };
+    const parsed = parseRegistry(raw);
+    if (!parsed) throw new Error(`invalid monitor state at ${this.stateFile}; refusing to overwrite`);
+    return parsed;
+  }
+  async acquireExclusive() {
+    const lockPath = path.join(this.stateDir, ".monitors.lock");
+    await mkdir(this.stateDir, { recursive: true });
+    const pid = String(process.pid);
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        const handle = await open(lockPath, "wx");
+        await handle.writeFile(pid);
+        let released = false;
+        return async () => {
+          if (released) return;
+          released = true;
+          await handle.close();
+          const current = await readLockPid(lockPath);
+          if (current === process.pid) await rm(lockPath, { force: true });
+        };
+      } catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+        if (code !== "EEXIST") throw error;
+        const holder = await readLockPid(lockPath);
+        if (holder === void 0 || processAlive(holder)) {
+          throw new Error(`another sourcefed daemon (pid ${holder ?? "unknown"}) is using ${this.stateDir}; stop it or set SOURCEFED_STATE_DIR`);
+        }
+        const contender = `${lockPath}.${process.pid}.${Date.now().toString(36)}`;
+        try {
+          await rename(lockPath, contender);
+        } catch {
+          continue;
+        }
+        await writeFile(contender, pid);
+        try {
+          await link(contender, lockPath);
+        } catch {
+          await rm(contender, { force: true });
+          continue;
+        }
+        await rm(contender, { force: true });
+        let released = false;
+        return async () => {
+          if (released) return;
+          released = true;
+          const current = await readLockPid(lockPath);
+          if (current === process.pid) await rm(lockPath, { force: true });
+        };
+      }
+    }
+    throw new Error(`could not acquire the sourcefed state lock at ${lockPath}`);
+  }
+  async save(registry) {
+    await mkdir(this.stateDir, { recursive: true, mode: 448 });
+    const temporary = `${this.stateFile}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(registry, null, 2)}
+`, { mode: 384 });
+    await rename(temporary, this.stateFile);
+  }
+  async readRaw(filePath) {
+    try {
+      const contents = await readFile(filePath, "utf8");
+      return JSON.parse(contents);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+};
+async function readLockPid(lockPath) {
+  try {
+    const contents = await readFile(lockPath, "utf8");
+    const pid = Number(contents.trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "EPERM");
+  }
+}
+function parseRegistry(value) {
+  const result = /* @__PURE__ */ safeParse(MonitorRegistrySchema, value);
+  return result.success ? result.output : void 0;
+}
+var JsonMonitorEventQueue = class {
+  constructor(stateDir) {
+    this.stateDir = stateDir;
+    this.eventsFile = path.join(stateDir, "events.json");
+  }
+  eventsFile;
+  queue = Promise.resolve();
+  async enqueue(input) {
+    return this.transact((events) => {
+      const queued = createQueuedMonitorEvent(input.monitor, input.event);
+      const existing = events.find((event) => event.id === queued.id);
+      if (existing) return existing;
+      events.push(queued);
+      return queued;
+    });
+  }
+  async read(target) {
+    const events = await this.loadEvents();
+    return events.filter((event) => sameTarget2(event.target, target));
+  }
+  async acknowledge(target, eventIDs) {
+    await this.transact((events) => {
+      const ids = new Set(eventIDs);
+      for (let index = events.length - 1; index >= 0; index -= 1) {
+        if (sameTarget2(events[index].target, target) && ids.has(events[index].id)) events.splice(index, 1);
+      }
+    });
+  }
+  async transact(operation) {
+    const next = this.queue.then(async () => {
+      const events = await this.loadEvents();
+      const result = await operation(events);
+      await this.saveEvents(events);
+      return result;
+    });
+    this.queue = next.then(() => void 0, () => void 0);
+    return next;
+  }
+  async loadEvents() {
+    try {
+      const contents = await readFile(this.eventsFile, "utf8");
+      const parsed = JSON.parse(contents);
+      if (!Array.isArray(parsed)) throw new Error(`invalid event queue at ${this.eventsFile}`);
+      return parsed;
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return [];
+      throw error;
+    }
+  }
+  async saveEvents(events) {
+    await mkdir(this.stateDir, { recursive: true, mode: 448 });
+    const temporary = `${this.eventsFile}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(events, null, 2)}
+`, { mode: 384 });
+    await rename(temporary, this.eventsFile);
+  }
+};
+function sameTarget2(left, right) {
+  return left.kind === right.kind && left.id === right.id;
+}
+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");
+}
+
+export {
+  MonitorRuntime,
+  JsonMonitorStore,
+  JsonMonitorEventQueue,
+  eventToText
+};