@fdcn/sourcefed 0.2.0

package/dist/chunk-NGJ6F5ST.js

@@ -0,0 +1,766 @@
+// packages/core/src/storage/in-memory-monitor-store.ts
+var InMemoryMonitorStore = class {
+  registry;
+  constructor(initial = { monitors: [] }) {
+    this.registry = structuredClone(initial);
+  }
+  async load() {
+    return structuredClone(this.registry);
+  }
+  async save(registry) {
+    this.registry = structuredClone(registry);
+  }
+};
+
+// packages/core/src/storage/json.ts
+import { link, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// node_modules/valibot/dist/index.mjs
+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 optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__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
+  };
+}
+
+// packages/core/src/events.ts
+var QueueMonitorEventSink = class {
+  constructor(queue) {
+    this.queue = queue;
+  }
+  async deliver(input) {
+    try {
+      await this.queue.enqueue(input);
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+};
+var InMemoryMonitorEventQueue = class {
+  events = [];
+  async enqueue(input) {
+    const queued = createQueuedMonitorEvent(input.monitor, input.event);
+    const existing = this.events.find((event) => event.id === queued.id);
+    if (existing) return existing;
+    this.events.push(queued);
+    return queued;
+  }
+  async read(target) {
+    return this.events.filter((event) => sameTarget(event.target, target)).map((event) => structuredClone(event));
+  }
+  async acknowledge(target, eventIDs) {
+    const ids = new Set(eventIDs);
+    for (let index = this.events.length - 1; index >= 0; index -= 1) {
+      if (sameTarget(this.events[index].target, target) && ids.has(this.events[index].id)) this.events.splice(index, 1);
+    }
+  }
+};
+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}`;
+}
+function sameTarget(left, right) {
+  return left.kind === right.kind && left.id === right.id;
+}
+
+// packages/core/src/sources/schema.ts
+var MonitorSourceSchema = intersect([
+  object({ type: string() }),
+  record(string(), unknown())
+]);
+
+// packages/core/src/monitors/schema.ts
+var MonitorRecordSchema = object({
+  id: string(),
+  name: string(),
+  source: MonitorSourceSchema,
+  delivery: picklist(["poll", "webhook"]),
+  target: object({
+    kind: string(),
+    id: string()
+  }),
+  pollIntervalSec: number(),
+  enabled: boolean(),
+  createdAt: string(),
+  updatedAt: string(),
+  cursors: record(string(), unknown())
+});
+var MonitorRegistrySchema = object({
+  monitors: array(MonitorRecordSchema)
+});
+
+// packages/core/src/storage/json.ts
+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 = safeParse(MonitorRegistrySchema, value);
+  return result.success ? result.output : void 0;
+}
+function defaultJsonMonitorStore(options = {}) {
+  return new JsonMonitorStore(options);
+}
+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;
+}
+
+export {
+  array,
+  boolean,
+  object,
+  optional,
+  string,
+  unknown,
+  safeParse,
+  QueueMonitorEventSink,
+  InMemoryMonitorEventQueue,
+  createQueuedMonitorEvent,
+  monitorEventID,
+  InMemoryMonitorStore,
+  MonitorRecordSchema,
+  MonitorRegistrySchema,
+  JsonMonitorStore,
+  defaultJsonMonitorStore,
+  JsonMonitorEventQueue
+};