@sixb/core 0.0.1

package/dist/chunk-yxss87qa.js

@@ -0,0 +1,821 @@
+// @bun
+import {
+  reportEventDeliveryFailure
+} from "./chunk-t72dvahb.js";
+import {
+  getInvalidJsonValueReason
+} from "./chunk-1vffvydj.js";
+
+// src/events/errors.ts
+class EventsError extends Error {
+  name = "EventsError";
+}
+
+// src/events/definitions.ts
+function defineEventGroup(definitions) {
+  return definitions;
+}
+var OBJECT_EVENT_DEFINITIONS = defineEventGroup({
+  "object.created": {
+    topic: "objects",
+    partitionKey: (payload) => `${payload.objectTypeId}:${payload.primaryId}`
+  },
+  "object.updated": {
+    topic: "objects",
+    partitionKey: (payload) => `${payload.objectTypeId}:${payload.primaryId}`
+  },
+  "object.deleted": {
+    topic: "objects",
+    partitionKey: (payload) => `${payload.objectTypeId}:${payload.primaryId}`
+  }
+});
+var TELEMETRY_EVENT_DEFINITIONS = defineEventGroup({
+  "telemetry.appended": {
+    topic: "telemetry",
+    partitionKey: (payload) => `${payload.objectTypeId}:${payload.objectId}:${payload.propertyId}`
+  }
+});
+var LINK_EVENT_DEFINITIONS = defineEventGroup({
+  "link.created": {
+    topic: "links",
+    partitionKey: (payload) => `${payload.sourceTypeId}:${payload.sourceId}:${payload.linkId}`
+  },
+  "link.updated": {
+    topic: "links",
+    partitionKey: (payload) => `${payload.sourceTypeId}:${payload.sourceId}:${payload.linkId}`
+  },
+  "link.deleted": {
+    topic: "links",
+    partitionKey: (payload) => `${payload.sourceTypeId}:${payload.sourceId}:${payload.linkId}`
+  }
+});
+var ACTION_EVENT_DEFINITIONS = defineEventGroup({
+  "action.requested": {
+    topic: "actions",
+    partitionKey: (payload) => payload.actionId
+  },
+  "action.completed": {
+    topic: "actions",
+    partitionKey: (payload) => payload.actionId
+  },
+  "action.failed": {
+    topic: "actions",
+    partitionKey: (payload) => payload.actionId
+  }
+});
+var SCHEDULE_EVENT_DEFINITIONS = defineEventGroup({
+  "schedule.triggered": {
+    topic: "schedules",
+    partitionKey: (payload) => payload.scheduleId
+  }
+});
+var RULE_EVENT_DEFINITIONS = defineEventGroup({
+  "rule.triggered": {
+    topic: "rules",
+    partitionKey: (payload) => `${payload.ruleId}:${payload.subject.objectTypeId}:${payload.subject.primaryId}`
+  },
+  "rule.resolved": {
+    topic: "rules",
+    partitionKey: (payload) => `${payload.ruleId}:${payload.subject.objectTypeId}:${payload.subject.primaryId}`
+  }
+});
+var SYNC_EVENT_DEFINITIONS = defineEventGroup({
+  "sync.run.started": {
+    topic: "syncs",
+    partitionKey: (payload) => `${payload.syncId}:${payload.runId}`
+  },
+  "sync.run.finished": {
+    topic: "syncs",
+    partitionKey: (payload) => `${payload.syncId}:${payload.runId}`
+  }
+});
+var PIPELINE_EVENT_DEFINITIONS = defineEventGroup({
+  "pipeline.run.started": {
+    topic: "pipelines",
+    partitionKey: (payload) => `${payload.pipelineId}:${payload.runId}`
+  },
+  "pipeline.run.step.started": {
+    topic: "pipelines",
+    partitionKey: (payload) => `${payload.pipelineId}:${payload.runId}`
+  },
+  "pipeline.run.step.finished": {
+    topic: "pipelines",
+    partitionKey: (payload) => `${payload.pipelineId}:${payload.runId}`
+  },
+  "pipeline.run.finished": {
+    topic: "pipelines",
+    partitionKey: (payload) => `${payload.pipelineId}:${payload.runId}`
+  }
+});
+var WORKFLOW_EVENT_DEFINITIONS = defineEventGroup({
+  "workflow.run.queued": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.run.started": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.run.node.started": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.run.waiting": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.run.node.waiting": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.run.node.finished": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.run.finished": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.intervention.requested": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.intervention.submitted": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.intervention.cancelled": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  },
+  "workflow.intervention.expired": {
+    topic: "workflows",
+    partitionKey: (payload) => `${payload.workflowId}:${payload.runId}`
+  }
+});
+var DATASET_EVENT_DEFINITIONS = defineEventGroup({
+  "dataset.version.committed": {
+    topic: "datasets",
+    partitionKey: (payload) => payload.datasetId
+  }
+});
+var EVENT_DEFINITIONS = {
+  ...OBJECT_EVENT_DEFINITIONS,
+  ...TELEMETRY_EVENT_DEFINITIONS,
+  ...LINK_EVENT_DEFINITIONS,
+  ...ACTION_EVENT_DEFINITIONS,
+  ...SCHEDULE_EVENT_DEFINITIONS,
+  ...SYNC_EVENT_DEFINITIONS,
+  ...PIPELINE_EVENT_DEFINITIONS,
+  ...WORKFLOW_EVENT_DEFINITIONS,
+  ...DATASET_EVENT_DEFINITIONS,
+  ...RULE_EVENT_DEFINITIONS
+};
+var EVENT_TYPES = Object.keys(EVENT_DEFINITIONS);
+var EVENT_TOPICS = [
+  ...new Set(Object.values(EVENT_DEFINITIONS).map((definition) => definition.topic))
+];
+function isDomainEventType(value) {
+  return Object.hasOwn(EVENT_DEFINITIONS, value);
+}
+function isOntologyFactType(value) {
+  return Object.hasOwn(OBJECT_EVENT_DEFINITIONS, value) || Object.hasOwn(LINK_EVENT_DEFINITIONS, value) || Object.hasOwn(TELEMETRY_EVENT_DEFINITIONS, value);
+}
+function getEventTopic(type) {
+  return EVENT_DEFINITIONS[type].topic;
+}
+function resolveEventStorage(event) {
+  const eventType = event.type;
+  if (!isDomainEventType(eventType)) {
+    throw new EventsError(`Unknown event type: ${eventType}`);
+  }
+  const definition = EVENT_DEFINITIONS[eventType];
+  return {
+    topic: definition.topic,
+    partitionKey: definition.partitionKey(event.payload)
+  };
+}
+// src/events/outbox-dispatcher.ts
+import { randomUUID } from "crypto";
+var DEFAULT_BATCH_SIZE = 100;
+var DEFAULT_LEASE_DURATION_MS = 30000;
+var DEFAULT_INITIAL_RETRY_DELAY_MS = 1000;
+var DEFAULT_MAX_RETRY_DELAY_MS = 5 * 60000;
+var DEFAULT_RETRY_JITTER_RATIO = 0.2;
+var DEFAULT_MAX_ISOLATION_ATTEMPTS = 16;
+var DEFAULT_MAX_CLAIMS_PER_DRAIN = 10;
+var DEFAULT_SHUTDOWN_TIMEOUT_MS = 30000;
+var SHUTDOWN_RESCHEDULE_ERROR = "Outbox dispatcher stopped before publication completed.";
+
+class ClaimedBatch {
+  unsettled = new Map;
+  closed = false;
+  constructor(rows) {
+    for (const row of rows)
+      this.unsettled.set(row.envelope.id, row);
+  }
+  take(rows) {
+    if (this.closed || rows.some((row) => !this.unsettled.has(row.envelope.id)))
+      return [];
+    for (const row of rows)
+      this.unsettled.delete(row.envelope.id);
+    return rows;
+  }
+  close() {
+    this.closed = true;
+    const rows = [...this.unsettled.values()];
+    this.unsettled.clear();
+    return rows;
+  }
+}
+
+class OntologyOutboxDispatcher {
+  projectId;
+  storage;
+  events;
+  batchSize;
+  leaseDurationMs;
+  initialRetryDelayMs;
+  maxRetryDelayMs;
+  retryJitterRatio;
+  maxIsolationAttempts;
+  maxClaimsPerDrain;
+  shutdownTimeoutMs;
+  now;
+  random;
+  createLeaseId;
+  onDeliveryFailure;
+  onError;
+  inFlight = new Set;
+  draining = null;
+  pendingDrain = null;
+  stopping = null;
+  stopRequested = false;
+  forcedStop = new AbortController;
+  constructor(options) {
+    assertNonblank(options.projectId, "projectId");
+    this.projectId = options.projectId;
+    this.storage = options.storage;
+    this.events = options.events;
+    this.batchSize = positiveInteger(options.batchSize ?? DEFAULT_BATCH_SIZE, "batchSize");
+    this.leaseDurationMs = positiveInteger(options.leaseDurationMs ?? DEFAULT_LEASE_DURATION_MS, "leaseDurationMs");
+    this.initialRetryDelayMs = positiveInteger(options.initialRetryDelayMs ?? DEFAULT_INITIAL_RETRY_DELAY_MS, "initialRetryDelayMs");
+    this.maxRetryDelayMs = positiveInteger(options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS, "maxRetryDelayMs");
+    if (this.maxRetryDelayMs < this.initialRetryDelayMs) {
+      throw new Error("[Sixb] Ontology outbox dispatcher maxRetryDelayMs must be at least initialRetryDelayMs.");
+    }
+    this.retryJitterRatio = options.retryJitterRatio ?? DEFAULT_RETRY_JITTER_RATIO;
+    if (!Number.isFinite(this.retryJitterRatio) || this.retryJitterRatio < 0 || this.retryJitterRatio > 1) {
+      throw new Error("[Sixb] Ontology outbox dispatcher retryJitterRatio must be between 0 and 1.");
+    }
+    this.maxIsolationAttempts = positiveInteger(options.maxIsolationAttempts ?? DEFAULT_MAX_ISOLATION_ATTEMPTS, "maxIsolationAttempts");
+    this.maxClaimsPerDrain = positiveInteger(options.maxClaimsPerDrain ?? DEFAULT_MAX_CLAIMS_PER_DRAIN, "maxClaimsPerDrain");
+    this.shutdownTimeoutMs = nonnegativeInteger(options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
+    this.now = options.now ?? (() => new Date);
+    this.random = options.random ?? Math.random;
+    this.createLeaseId = options.createLeaseId ?? randomUUID;
+    this.onDeliveryFailure = options.onDeliveryFailure;
+    this.onError = options.onError ?? ((error) => console.error("[Sixb] Outbox dispatcher error:", error));
+  }
+  drain() {
+    if (this.stopRequested)
+      return Promise.resolve();
+    if (!this.draining)
+      return this.startDrainPass();
+    this.pendingDrain ??= settled(this.draining).then(() => {
+      this.pendingDrain = null;
+      if (!this.stopRequested)
+        return this.startDrainPass();
+    });
+    return this.pendingDrain;
+  }
+  notify() {
+    if (this.stopRequested)
+      return;
+    this.drain().catch((error) => this.reportError(error));
+  }
+  stop() {
+    this.stopping ??= this.stopOnce();
+    return this.stopping;
+  }
+  async stopOnce() {
+    if (this.stopRequested)
+      return;
+    const gracefulDrain = this.drain().catch((error) => this.reportError(error));
+    if (await settlesWithin(gracefulDrain, this.shutdownTimeoutMs)) {
+      this.stopRequested = true;
+      return;
+    }
+    this.stopRequested = true;
+    this.forcedStop.abort();
+    await settlesWithin(this.rescheduleUnsettledForShutdown(), Math.min(this.shutdownTimeoutMs, 1000));
+    this.draining = null;
+    this.pendingDrain = null;
+  }
+  startDrainPass() {
+    const pass = this.drainAvailable();
+    this.draining = pass;
+    settled(pass).then(() => {
+      if (this.draining === pass)
+        this.draining = null;
+    });
+    return pass;
+  }
+  async drainAvailable() {
+    for (let claimCount = 0;claimCount < this.maxClaimsPerDrain; claimCount += 1) {
+      if (this.stopRequested)
+        return;
+      const rows = await this.claimBatch();
+      if (rows.length === 0)
+        return;
+      const publishedCount = await this.publishClaim(rows);
+      if (this.stopRequested || publishedCount === 0 || rows.length < this.batchSize)
+        return;
+    }
+    if (!this.stopRequested)
+      this.notify();
+  }
+  claimBatch() {
+    const now = this.now().getTime();
+    return this.withOutbox((outbox) => outbox.claim({
+      projectId: this.projectId,
+      now: new Date(now).toISOString(),
+      limit: this.batchSize,
+      leaseId: this.createLeaseId(),
+      leaseExpiresAt: new Date(now + this.leaseDurationMs).toISOString()
+    }));
+  }
+  async publishClaim(rows) {
+    const claim = new ClaimedBatch(rows);
+    const failures = new DeliveryFailureAccumulator;
+    this.inFlight.add(claim);
+    const pending = [{ rows }];
+    let publishAttempts = 0;
+    let publishedCount = 0;
+    try {
+      while (pending.length > 0 && !this.stopRequested) {
+        const group = pending.shift();
+        if (!group || group.rows.length === 0)
+          continue;
+        if (publishAttempts >= this.maxIsolationAttempts && group.failure) {
+          await this.rescheduleFailed(claim, group.rows, group.failure.error, failures);
+          continue;
+        }
+        publishAttempts += 1;
+        try {
+          const publication = await publishUntilStopped(this.events.publishEnvelopes(group.rows.map((row) => row.envelope)), this.forcedStop.signal);
+          if (publication === "stopped")
+            break;
+        } catch (error) {
+          if (group.rows.length > 1 && publishAttempts < this.maxIsolationAttempts) {
+            const middle = Math.ceil(group.rows.length / 2);
+            pending.unshift({ rows: group.rows.slice(middle), failure: { error } }, { rows: group.rows.slice(0, middle), failure: { error } });
+            continue;
+          }
+          await this.rescheduleFailed(claim, group.rows, error, failures);
+          continue;
+        }
+        await this.markPublished(claim, group.rows);
+        publishedCount += group.rows.length;
+      }
+    } finally {
+      if (this.stopRequested) {
+        await this.rescheduleClaimedForShutdown(claim.close());
+      }
+      this.inFlight.delete(claim);
+      for (const failure of failures.list()) {
+        this.reportDeliveryFailure(failure.error, failure.context);
+      }
+    }
+    return publishedCount;
+  }
+  async markPublished(claim, rows) {
+    const settling = claim.take(rows);
+    if (settling.length === 0)
+      return;
+    try {
+      await this.withOutbox((outbox) => outbox.markPublished({
+        projectId: this.projectId,
+        ids: eventIds(settling),
+        leaseId: sharedLeaseId(settling),
+        publishedAt: this.now().toISOString()
+      }));
+    } catch (error) {
+      this.reportError(error);
+      throw error;
+    }
+  }
+  async rescheduleFailed(claim, rows, error, failures) {
+    const settling = claim.take(rows);
+    if (settling.length === 0)
+      return;
+    const failedAt = this.now();
+    for (const [attempts, attemptRows] of rowsByAttempts(settling)) {
+      failures.add(error, failedAt.toISOString(), attempts, attemptRows);
+      try {
+        await this.withOutbox((outbox) => outbox.reschedule({
+          projectId: this.projectId,
+          ids: eventIds(attemptRows),
+          leaseId: sharedLeaseId(attemptRows),
+          availableAt: new Date(failedAt.getTime() + this.retryDelayMs(attempts)).toISOString(),
+          error: errorMessage(error)
+        }));
+      } catch (rescheduleError) {
+        this.reportError(rescheduleError);
+        throw rescheduleError;
+      }
+    }
+  }
+  retryDelayMs(attempts) {
+    const exponent = Math.max(0, Math.min(52, attempts - 1));
+    const exponential = Math.min(this.maxRetryDelayMs, this.initialRetryDelayMs * 2 ** exponent);
+    const random = this.random();
+    const unitRandom = Number.isFinite(random) ? Math.max(0, Math.min(1, random)) : 0.5;
+    const jitterFactor = 1 - this.retryJitterRatio + 2 * this.retryJitterRatio * unitRandom;
+    return Math.min(this.maxRetryDelayMs, Math.max(0, Math.round(exponential * jitterFactor)));
+  }
+  async rescheduleClaimedForShutdown(rows) {
+    if (rows.length === 0)
+      return;
+    try {
+      await this.withOutbox((outbox) => outbox.reschedule({
+        projectId: this.projectId,
+        ids: eventIds(rows),
+        leaseId: sharedLeaseId(rows),
+        availableAt: this.now().toISOString(),
+        error: SHUTDOWN_RESCHEDULE_ERROR
+      }));
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async rescheduleUnsettledForShutdown() {
+    for (const claim of [...this.inFlight]) {
+      await this.rescheduleClaimedForShutdown(claim.close());
+      this.inFlight.delete(claim);
+    }
+  }
+  withOutbox(run) {
+    return this.storage.transaction((tx) => run(tx.ontology.outbox));
+  }
+  reportDeliveryFailure(error, failure) {
+    try {
+      this.onDeliveryFailure?.(error, failure);
+    } catch {}
+  }
+  reportError(error) {
+    try {
+      this.onError(error);
+    } catch {}
+  }
+}
+
+class DeliveryFailureAccumulator {
+  groups = new Map;
+  add(error, occurredAt, attempts, rows) {
+    const group = this.groups.get(attempts) ?? {
+      error,
+      occurredAt,
+      eventIds: new Set,
+      eventTypes: new Set
+    };
+    for (const row of rows) {
+      group.eventIds.add(row.envelope.id);
+      group.eventTypes.add(row.envelope.type);
+    }
+    this.groups.set(attempts, group);
+  }
+  list() {
+    return [...this.groups.entries()].map(([attempts, group]) => ({
+      error: group.error,
+      context: {
+        occurredAt: group.occurredAt,
+        attempts,
+        eventIds: [...group.eventIds].sort(),
+        eventTypes: [...group.eventTypes].sort()
+      }
+    }));
+  }
+}
+function positiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`[Sixb] Ontology outbox dispatcher ${name} must be a positive integer.`);
+  }
+  return value;
+}
+function nonnegativeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`[Sixb] Ontology outbox dispatcher ${name} must be a nonnegative integer.`);
+  }
+  return value;
+}
+function assertNonblank(value, name) {
+  if (value.trim().length === 0) {
+    throw new Error(`[Sixb] Ontology outbox dispatcher ${name} must not be blank.`);
+  }
+}
+function rowsByAttempts(rows) {
+  const groups = new Map;
+  for (const row of rows) {
+    const group = groups.get(row.attempts) ?? [];
+    group.push(row);
+    groups.set(row.attempts, group);
+  }
+  return groups;
+}
+function eventIds(rows) {
+  return rows.map((row) => row.envelope.id);
+}
+function sharedLeaseId(rows) {
+  const leaseId = rows[0]?.leaseId;
+  if (!leaseId || rows.some((row) => row.leaseId !== leaseId)) {
+    throw new Error("[Sixb] Claimed ontology outbox batch does not share one lease.");
+  }
+  return leaseId;
+}
+function errorMessage(error) {
+  const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  return message.slice(0, 2000);
+}
+async function publishUntilStopped(publication, signal) {
+  if (signal.aborted)
+    return "stopped";
+  return new Promise((resolve, reject) => {
+    const stop = () => finish(() => resolve("stopped"));
+    const finish = (settle) => {
+      signal.removeEventListener("abort", stop);
+      settle();
+    };
+    signal.addEventListener("abort", stop, { once: true });
+    publication.then(() => finish(() => resolve("published")), (error) => finish(() => reject(error)));
+  });
+}
+function settled(promise) {
+  return promise.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+}
+async function settlesWithin(promise, timeoutMs) {
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(false), timeoutMs);
+  });
+  const result = await Promise.race([
+    promise.then(() => true, () => true),
+    timedOut
+  ]);
+  if (timer !== undefined)
+    clearTimeout(timer);
+  return result;
+}
+// src/events/runtime.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_EVENTS_RETENTION_MS = 2 * 24 * 60 * 60 * 1000;
+var EVENTS_STREAM = {
+  id: "__events",
+  retention: { maxAgeMs: DEFAULT_EVENTS_RETENTION_MS }
+};
+
+class EventsRuntime {
+  projectId;
+  broker;
+  stream;
+  host;
+  ensureStreamPromises = new Map;
+  constructor(options) {
+    this.projectId = options.projectId;
+    this.broker = options.broker;
+    this.stream = options.stream ?? EVENTS_STREAM;
+    this.host = options.host;
+  }
+  async emit(input, options) {
+    try {
+      await this.append(input);
+    } catch (error) {
+      try {
+        const eventTypes = input.events.map((event) => event.type);
+        reportEventDeliveryFailure(this.host, error, {
+          projectId: this.projectId,
+          eventTypes
+        });
+        console.error(`[${options.source}] Failed to emit ${eventTypes.join(", ")}:`, error);
+      } catch {}
+    }
+  }
+  async append(input) {
+    if (input.events.length === 0) {
+      return [];
+    }
+    for (const event of input.events) {
+      if (isOntologyFactType(event.type)) {
+        throw new EventsError(`Event type '${event.type}' is an authoritative ontology fact and cannot be appended directly.`);
+      }
+    }
+    const payloads = input.events.map((event) => toStoredEventPayload({
+      projectId: this.projectId,
+      actor: input.actor,
+      correlationId: input.correlationId,
+      causationId: input.causationId,
+      event
+    }));
+    await this.ensureStream();
+    const records = await this.broker.append({
+      projectId: this.projectId,
+      streamId: this.stream.id,
+      records: payloads.map((payload) => ({
+        name: payload.type,
+        key: payload.partitionKey,
+        payload: toBrokerRecordPayload(payload),
+        idempotencyKey: payload.idempotencyKey
+      }))
+    });
+    if (records.length !== payloads.length) {
+      throw new EventsError(`Broker returned ${records.length} record(s) for ${payloads.length} appended event(s).`);
+    }
+    return records.map(hydrateEventRecord);
+  }
+  async publishEnvelopes(envelopes) {
+    if (envelopes.length === 0) {
+      return [];
+    }
+    for (const envelope of envelopes) {
+      if (envelope.projectId !== this.projectId) {
+        throw new EventsError(`Event '${envelope.id}' belongs to project '${envelope.projectId}', not '${this.projectId}'.`);
+      }
+      if (!isDomainEventType(envelope.type)) {
+        throw new EventsError(`Event '${envelope.id}' has unknown event type.`);
+      }
+      if (EVENT_DEFINITIONS[envelope.type].topic !== envelope.topic) {
+        throw new EventsError(`Event '${envelope.id}' topic '${envelope.topic}' does not match type '${envelope.type}'.`);
+      }
+    }
+    await this.ensureStream();
+    const records = await this.broker.append({
+      projectId: this.projectId,
+      streamId: this.stream.id,
+      records: envelopes.map((envelope) => ({
+        name: envelope.type,
+        key: envelope.partitionKey,
+        payload: toBrokerRecordPayload(envelope),
+        idempotencyKey: envelope.id
+      }))
+    });
+    if (records.length !== envelopes.length) {
+      throw new EventsError(`Broker returned ${records.length} record(s) for ${envelopes.length} published event(s).`);
+    }
+    return records.map(hydrateEventRecord);
+  }
+  async read(input = {}) {
+    if (input.limit !== undefined && input.limit <= 0) {
+      return [];
+    }
+    const names = resolveTypeFilter(input);
+    if (names && names.length === 0) {
+      return [];
+    }
+    await this.ensureStream();
+    const page = await this.broker.read({
+      projectId: this.projectId,
+      streamId: this.stream.id,
+      afterCursor: input.afterCursor,
+      limit: input.limit,
+      names
+    });
+    return page.records.map(hydrateEventRecord);
+  }
+  async latestCursor() {
+    await this.ensureStream();
+    return this.broker.latestCursor({
+      projectId: this.projectId,
+      streamId: this.stream.id
+    });
+  }
+  async subscribe(input, handler) {
+    await this.ensureStream();
+    return this.broker.subscribe({
+      projectId: this.projectId,
+      streamId: this.stream.id,
+      from: input.from,
+      afterCursor: input.afterCursor,
+      names: input.types && input.types.length > 0 ? input.types : EVENT_TYPES
+    }, (records) => {
+      const events = records.map(hydrateEventRecord);
+      if (events.length === 0) {
+        return;
+      }
+      try {
+        handler(events);
+      } catch {}
+    });
+  }
+  ensureStream() {
+    const key = `${this.projectId}\x00${this.stream.id}`;
+    let promise = this.ensureStreamPromises.get(key);
+    if (!promise) {
+      promise = this.broker.ensureStream({
+        projectId: this.projectId,
+        stream: this.stream
+      }).catch((error) => {
+        if (this.ensureStreamPromises.get(key) === promise) {
+          this.ensureStreamPromises.delete(key);
+        }
+        throw error;
+      });
+      this.ensureStreamPromises.set(key, promise);
+    }
+    return promise;
+  }
+}
+function toStoredEventPayload(params) {
+  const storage = resolveEventStorage(params.event);
+  const payload = {
+    id: randomUUID2(),
+    schemaVersion: 1,
+    projectId: params.projectId,
+    occurredAt: params.event.occurredAt ?? new Date().toISOString(),
+    type: params.event.type,
+    topic: storage.topic,
+    partitionKey: storage.partitionKey,
+    payload: params.event.payload
+  };
+  setIfDefined(payload, "correlationId", params.correlationId);
+  setIfDefined(payload, "causationId", params.causationId);
+  setIfDefined(payload, "idempotencyKey", params.event.idempotencyKey);
+  setIfDefined(payload, "actor", params.actor);
+  setIfDefined(payload, "origin", params.event.origin);
+  setIfDefined(payload, "metadata", params.event.metadata);
+  return payload;
+}
+function toBrokerRecordPayload(payload) {
+  const reason = getInvalidJsonValueReason(payload, `event '${payload.type}' payload`);
+  if (reason) {
+    throw new EventsError(`Event '${payload.type}' cannot be stored in broker; ${reason}`);
+  }
+  return payload;
+}
+function hydrateEventRecord(record) {
+  const payload = record.payload;
+  if (!isObjectRecord(payload)) {
+    throw new EventsError(`Broker record at cursor '${record.cursor}' is not an event object.`);
+  }
+  const eventType = payload.type;
+  if (typeof eventType !== "string" || !isDomainEventType(eventType)) {
+    throw new EventsError(`Broker record at cursor '${record.cursor}' has unknown event type.`);
+  }
+  if (record.name !== undefined && record.name !== eventType) {
+    throw new EventsError(`Broker record name '${record.name}' does not match event type '${eventType}'.`);
+  }
+  return {
+    ...payload,
+    cursor: record.cursor
+  };
+}
+function resolveTypeFilter(input) {
+  const topicTypes = input.topics && input.topics.length > 0 ? EVENT_TYPES.filter((type) => input.topics?.includes(EVENT_DEFINITIONS[type].topic)) : undefined;
+  if (!topicTypes) {
+    return input.types && input.types.length > 0 ? input.types : EVENT_TYPES;
+  }
+  if (!input.types || input.types.length === 0) {
+    return topicTypes;
+  }
+  const requestedTypes = new Set(input.types);
+  return topicTypes.filter((type) => requestedTypes.has(type));
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function setIfDefined(target, key, value) {
+  if (value !== undefined) {
+    target[key] = value;
+  }
+}
+// src/events/toStoredEvent.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function toStoredEvent(params) {
+  const base = {
+    id: randomUUID3(),
+    schemaVersion: 1,
+    projectId: params.projectId,
+    occurredAt: params.event.occurredAt ?? new Date().toISOString(),
+    correlationId: params.correlationId,
+    causationId: params.causationId,
+    idempotencyKey: params.event.idempotencyKey,
+    actor: params.actor,
+    origin: params.event.origin,
+    metadata: params.event.metadata,
+    cursor: params.cursor
+  };
+  const storage = resolveEventStorage(params.event);
+  return {
+    ...base,
+    type: params.event.type,
+    topic: storage.topic,
+    partitionKey: storage.partitionKey,
+    payload: params.event.payload
+  };
+}
+export { EventsError, OBJECT_EVENT_DEFINITIONS, TELEMETRY_EVENT_DEFINITIONS, LINK_EVENT_DEFINITIONS, ACTION_EVENT_DEFINITIONS, SCHEDULE_EVENT_DEFINITIONS, RULE_EVENT_DEFINITIONS, SYNC_EVENT_DEFINITIONS, PIPELINE_EVENT_DEFINITIONS, WORKFLOW_EVENT_DEFINITIONS, DATASET_EVENT_DEFINITIONS, EVENT_DEFINITIONS, EVENT_TYPES, EVENT_TOPICS, isDomainEventType, isOntologyFactType, getEventTopic, resolveEventStorage, OntologyOutboxDispatcher, DEFAULT_EVENTS_RETENTION_MS, EVENTS_STREAM, EventsRuntime, toStoredEvent };
+
+//# debugId=DDB208C4130F7EB764756E2164756E21