@sekiban/dcb-runtime 0.2.0

package/dist/cosmos.js

@@ -0,0 +1,1411 @@
+// ../dcb-core/dist/index.js
+var DcbDefinitionError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "DcbDefinitionError";
+    this.code = code;
+  }
+};
+var CanonicalEventIdentityError = class extends DcbDefinitionError {
+  code = "CANONICAL_EVENT_IDENTITY_INVALID";
+  constructor(message) {
+    super("CANONICAL_EVENT_IDENTITY_INVALID", message);
+    this.name = "CanonicalEventIdentityError";
+  }
+};
+function canonicalEventKey(eventPayloadName) {
+  if (typeof eventPayloadName !== "string" || eventPayloadName.length === 0 || eventPayloadName.includes(":")) {
+    throw new CanonicalEventIdentityError("Event payload names must be non-empty and must not contain ':'");
+  }
+  return eventPayloadName;
+}
+function parseCanonicalEventKey(key) {
+  const canonical2 = canonicalEventKey(key);
+  if (canonical2 !== key) {
+    throw new CanonicalEventIdentityError("Event identity key is not canonical");
+  }
+  return Object.freeze({ eventPayloadName: key, key });
+}
+
+// src/eventIdentity.ts
+var DeliveryIdentityError = class extends Error {
+  code = "DELIVERY_IDENTITY_INVALID";
+  retryable = false;
+  constructor(message) {
+    super(message);
+    this.name = "DeliveryIdentityError";
+  }
+};
+var MissingCanonicalEventIdentityError = class extends DeliveryIdentityError {
+  code = "MISSING_CANONICAL_EVENT_IDENTITY";
+  constructor(source) {
+    super(`G32 ${source} delivery is missing canonical event identity`);
+    this.name = "MissingCanonicalEventIdentityError";
+  }
+};
+function provenanceFrom(value) {
+  if (value === void 0) return void 0;
+  if (value === "g32") return value;
+  throw new DeliveryIdentityError("Unknown event identity provenance");
+}
+function resolveDeliveryIdentity(message, source) {
+  const provenance = provenanceFrom(message.provenance);
+  if (message.eventType === void 0) {
+    throw new MissingCanonicalEventIdentityError(source);
+  }
+  const identity = parseCanonicalEventKey(message.eventType);
+  if (provenance !== "g32") {
+    throw new DeliveryIdentityError("G32 delivery provenance is required");
+  }
+  return {
+    ...identity,
+    provenance: "g32",
+    legacy: false
+  };
+}
+
+// src/allocator/SortableUniqueId.ts
+var SORTABLE_UNIQUE_ID_TICKS_DIGITS = 19;
+var SORTABLE_UNIQUE_ID_RANDOM_DIGITS = 11;
+var SORTABLE_UNIQUE_ID_DIGITS = SORTABLE_UNIQUE_ID_TICKS_DIGITS + SORTABLE_UNIQUE_ID_RANDOM_DIGITS;
+var DOTNET_UNIX_EPOCH_TICKS = 621355968000000000n;
+var DOTNET_MAX_TICKS = 3155378975999999999n;
+var DOTNET_TICKS_PER_MILLISECOND = 10000n;
+var SORTABLE_UNIQUE_ID_RANDOM_LIMIT = 10n ** BigInt(SORTABLE_UNIQUE_ID_RANDOM_DIGITS);
+var MAX_UNIX_MILLISECONDS = (DOTNET_MAX_TICKS - DOTNET_UNIX_EPOCH_TICKS) / DOTNET_TICKS_PER_MILLISECOND;
+var SortableUniqueIdError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "SortableUniqueIdError";
+  }
+  code;
+};
+var LEGACY_PREFIXED_SUID = /^suid-[0-9]+$/;
+var LEGACY_DECISION_OBSERVER = /* @__PURE__ */ Symbol.for("@sekiban/dcb-runtime/legacy-sortable-unique-id-observer");
+function legacyDecisionObserver() {
+  return globalThis[LEGACY_DECISION_OBSERVER];
+}
+function assertDotNetTicks(ticks) {
+  if (ticks < 0n || ticks > DOTNET_MAX_TICKS) {
+    throw new SortableUniqueIdError("SUID_TICKS_INVALID", "SortableUniqueId ticks are outside the .NET DateTime range");
+  }
+  return ticks;
+}
+function assertSortableUniqueId(value) {
+  if (typeof value === "string" && LEGACY_PREFIXED_SUID.test(value)) {
+    legacyDecisionObserver()?.(value);
+    throw new SortableUniqueIdError(
+      "SUID_LEGACY_FORMAT_RETIRED",
+      "Legacy prefixed SortableUniqueId is retired; G32 requires exactly 30 ASCII decimal digits"
+    );
+  }
+  if (typeof value !== "string" || !new RegExp(`^[0-9]{${SORTABLE_UNIQUE_ID_DIGITS}}$`).test(value)) {
+    throw new SortableUniqueIdError("SUID_INVALID", "SortableUniqueId must be exactly 30 ASCII decimal digits");
+  }
+  const ticksText = value.slice(0, SORTABLE_UNIQUE_ID_TICKS_DIGITS);
+  const randomText = value.slice(SORTABLE_UNIQUE_ID_TICKS_DIGITS);
+  const ticks = assertDotNetTicks(BigInt(ticksText));
+  const random = BigInt(randomText);
+  if (random < 0n || random >= SORTABLE_UNIQUE_ID_RANDOM_LIMIT) {
+    throw new SortableUniqueIdError("SUID_RANDOM_INVALID", "SortableUniqueId random suffix is outside its 11-digit range");
+  }
+  return Object.freeze({ value, ticks, random });
+}
+
+// src/eventRecord.ts
+var SERIALIZED_COMMIT_CORRELATION_ID = "SerializedCommit";
+var SERIALIZED_SEKIBAN_EXECUTOR = "SerializedSekibanExecutor";
+var CANONICAL_UTC_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{1,7}Z$/;
+function serializedEventMetadata(eventId) {
+  return Object.freeze({
+    causationId: eventId,
+    correlationId: SERIALIZED_COMMIT_CORRELATION_ID,
+    executedUser: SERIALIZED_SEKIBAN_EXECUTOR
+  });
+}
+function isRfc4122Uuid(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function isUuidV7(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
+}
+
+// src/safeWindow.ts
+function decayedLagEstimateMs(estimateMs, observedAtMs, nowMs) {
+  const elapsed = Math.max(0, nowMs - observedAtMs);
+  return Math.max(0, estimateMs - elapsed);
+}
+
+// src/store/types.ts
+var CanonicalEventIdentityConflictError = class extends Error {
+  constructor(provider, eventId, message) {
+    super(message ?? `${provider} EventId ${eventId} conflicts with its canonical event identity`);
+    this.provider = provider;
+    this.eventId = eventId;
+    this.name = "CanonicalEventIdentityConflictError";
+  }
+  provider;
+  eventId;
+  code = "CANONICAL_EVENT_IDENTITY_CONFLICT";
+};
+
+// src/store/CosmosEventStore.ts
+var COSMOS_EVENT_PARTITION_KEY_PATH = "/pk";
+var COSMOS_AUXILIARY_PARTITION_KEY_PATH = "/serviceId";
+var DEFAULT_COSMOS_CONTAINERS = Object.freeze({
+  events: "dcb-events",
+  lagEstimates: "dcb-lag-estimates",
+  pendingArrivals: "dcb-pending-arrivals",
+  findings: "dcb-findings",
+  checkpoints: "dcb-projection-checkpoints"
+});
+function cosmosContainerDefinitions(containers = DEFAULT_COSMOS_CONTAINERS) {
+  return [
+    {
+      name: containers.events,
+      partitionKeyPath: COSMOS_EVENT_PARTITION_KEY_PATH,
+      // The C# CosmosEvent is partitioned by the exact serviceId|id pair.
+      // Refuse a missing id here so an introspection fixture cannot mistake
+      // an auxiliary service partition for the logical event partition.
+      partitionKeyValue: (serviceId, id) => {
+        if (typeof id !== "string" || id.length === 0) throw new Error("Cosmos event partition key requires an event id");
+        return eventPk(serviceId, id);
+      }
+    },
+    ...[containers.lagEstimates, containers.pendingArrivals, containers.findings, containers.checkpoints].map((name) => ({
+      name,
+      partitionKeyPath: COSMOS_AUXILIARY_PARTITION_KEY_PATH,
+      partitionKeyValue: (serviceId) => serviceId
+    }))
+  ];
+}
+var CosmosClientError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "CosmosClientError";
+  }
+  status;
+};
+function asString(value, name) {
+  if (typeof value !== "string") throw new Error(`Cosmos ${name} was not a string`);
+  return value;
+}
+function nullableString(value, name) {
+  return value === null ? null : asString(value, name);
+}
+function asNumber(value, name) {
+  const number = typeof value === "number" ? value : Number(value);
+  if (!Number.isSafeInteger(number)) throw new Error(`Cosmos ${name} was not a safe integer`);
+  return number;
+}
+function asStringArray(value, name) {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+    throw new Error(`Cosmos ${name} was not a string array`);
+  }
+  return [...value];
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort(binaryCompare);
+}
+function binaryCompare(left, right) {
+  const leftBytes = new TextEncoder().encode(left);
+  const rightBytes = new TextEncoder().encode(right);
+  const shared = Math.min(leftBytes.length, rightBytes.length);
+  for (let index = 0; index < shared; index += 1) {
+    const difference = leftBytes[index] - rightBytes[index];
+    if (difference !== 0) return difference;
+  }
+  return leftBytes.length - rightBytes.length;
+}
+function assertUtcTimestamp(value, eventId) {
+  if (!CANONICAL_UTC_TIMESTAMP_PATTERN.test(value) || !Number.isFinite(Date.parse(value))) {
+    throw new CanonicalEventIdentityConflictError("cosmos", eventId, "Cosmos Timestamp must be canonical UTC ISO-8601");
+  }
+}
+function compareCosmosSuid(left, right) {
+  const leftBytes = new TextEncoder().encode(left);
+  const rightBytes = new TextEncoder().encode(right);
+  const shared = Math.min(leftBytes.length, rightBytes.length);
+  for (let index = 0; index < shared; index += 1) {
+    const difference = leftBytes[index] - rightBytes[index];
+    if (difference !== 0) return difference;
+  }
+  return leftBytes.length - rightBytes.length;
+}
+function safeId(...parts) {
+  return parts.map((part) => encodeURIComponent(part)).join("~");
+}
+function eventPk(serviceId, id) {
+  return `${serviceId}|${id}`;
+}
+function auxiliaryPk(serviceId) {
+  return eventPk(serviceId, "__dcb_event_ops__");
+}
+function isStatus(error, status) {
+  return error instanceof CosmosClientError && error.status === status;
+}
+function eventFrom(document, ops) {
+  const arrivals = Array.isArray(ops?.arrivals) ? ops.arrivals : [];
+  const id = asString(document.id, "id");
+  const tags = asStringArray(document.tags, "tags");
+  return {
+    serviceId: asString(document.serviceId, "serviceId"),
+    id,
+    eventId: id,
+    sortableUniqueId: asString(document.sortableUniqueId, "sortableUniqueId"),
+    suid: asString(document.sortableUniqueId, "sortableUniqueId"),
+    payload: asString(document.payload, "payload"),
+    tags,
+    eventTags: tags,
+    eventType: asString(document.eventType, "eventType"),
+    timestamp: asString(document.timestamp, "timestamp"),
+    causationId: nullableString(document.causationId, "causationId"),
+    correlationId: nullableString(document.correlationId, "correlationId"),
+    executedUser: nullableString(document.executedUser, "executedUser"),
+    provenance: "g32",
+    firstArrivedAt: ops === void 0 ? 0 : asNumber(ops.firstArrivedAt, "firstArrivedAt"),
+    lastArrivedAt: ops === void 0 ? 0 : asNumber(ops.lastArrivedAt, "lastArrivedAt"),
+    maxDeliveryLagMs: ops === void 0 ? 0 : asNumber(ops.maxDeliveryLagMs, "maxDeliveryLagMs"),
+    arrivals: arrivals.map((arrival) => {
+      if (typeof arrival !== "object" || arrival === null || Array.isArray(arrival)) {
+        throw new Error("Cosmos arrival was not an object");
+      }
+      const value = arrival;
+      return {
+        serviceId: asString(value.serviceId, "arrival.serviceId"),
+        eventId: asString(value.eventId, "arrival.eventId"),
+        tag: asString(value.tag, "arrival.tag"),
+        enqueuedAt: asNumber(value.enqueuedAt, "arrival.enqueuedAt"),
+        arrivedAt: asNumber(value.arrivedAt, "arrival.arrivedAt"),
+        lagMs: asNumber(value.lagMs, "arrival.lagMs")
+      };
+    })
+  };
+}
+function pendingFrom(document) {
+  return {
+    serviceId: asString(document.serviceId, "serviceId"),
+    attemptId: asString(document.attemptId, "attemptId"),
+    eventId: asString(document.eventId, "eventId"),
+    suid: asString(document.suid, "suid"),
+    expectedPaths: sortedUnique(asStringArray(document.expectedPaths, "expectedPaths")),
+    observedPaths: sortedUnique(asStringArray(document.observedPaths, "observedPaths")),
+    firstObservedAt: asNumber(document.firstObservedAt, "firstObservedAt"),
+    lagBoundMs: asNumber(document.lagBoundMs, "lagBoundMs")
+  };
+}
+function findingFrom(document) {
+  const classification = asString(document.classification, "classification");
+  if (classification !== "MISSING_STABLE" && classification !== "EXCLUDED_AUDITED" && classification !== "RESOLVED_LATE") {
+    throw new Error("Cosmos classification was invalid");
+  }
+  return {
+    serviceId: asString(document.serviceId, "serviceId"),
+    eventId: asString(document.eventId, "eventId"),
+    path: asString(document.path, "path"),
+    classification,
+    firstObservedAt: asNumber(document.firstObservedAt, "firstObservedAt"),
+    lagBoundMs: asNumber(document.lagBoundMs, "lagBoundMs"),
+    observedAt: asNumber(document.observedAt, "observedAt")
+  };
+}
+function incidentClassification(value) {
+  const classification = asString(value, "classification");
+  if (classification !== "SUID_COLLISION" && classification !== "ORDER_VIOLATION" && classification !== "LINEAGE_MISMATCH" && classification !== "ORDERING_DETECTOR_UNKNOWN") {
+    throw new Error("Cosmos delivery incident classification was invalid");
+  }
+  return classification;
+}
+function optionalString(value, name) {
+  if (value === null || value === void 0 || value === "") return void 0;
+  return asString(value, name);
+}
+function incidentFrom(document) {
+  return {
+    serviceId: asString(document.serviceId, "serviceId"),
+    identityKey: asString(document.identityKey, "identityKey"),
+    classification: incidentClassification(document.classification),
+    suid: optionalString(document.suid, "suid"),
+    existingEventId: optionalString(document.existingEventId, "existingEventId"),
+    incomingEventId: optionalString(document.incomingEventId, "incomingEventId"),
+    eventId: optionalString(document.eventId, "eventId"),
+    boundLineageId: optionalString(document.boundLineageId, "boundLineageId"),
+    incomingLineageId: optionalString(document.incomingLineageId, "incomingLineageId"),
+    observedAt: asNumber(document.observedAt, "observedAt")
+  };
+}
+function collisionIdentity(serviceId, suid, existingEventId, incomingEventId) {
+  const [first, second] = [existingEventId, incomingEventId].sort(binaryCompare);
+  return `SUID_COLLISION|${serviceId}|${suid}|${first}|${second}`;
+}
+function lineageIdentity(serviceId, boundLineageId, incomingLineageId) {
+  return `LINEAGE_MISMATCH|${serviceId}|${boundLineageId}|${incomingLineageId}`;
+}
+function metadataForDelivery(message, deliverySource) {
+  const serialized = serializedEventMetadata(message.eventId);
+  if (deliverySource !== "import") {
+    if (message.causationId !== serialized.causationId || message.correlationId !== serialized.correlationId || message.executedUser !== serialized.executedUser) {
+      throw new CanonicalEventIdentityConflictError("cosmos", message.eventId, "Cosmos metadata must use the serialized C# constants");
+    }
+    return serialized;
+  }
+  const values = [message.causationId, message.correlationId, message.executedUser];
+  if (!values.every((value) => value === null || typeof value === "string")) {
+    throw new CanonicalEventIdentityConflictError("cosmos", message.eventId, "Cosmos import metadata must be string or null");
+  }
+  const allNull = values.every((value) => value === null);
+  const allSerialized = message.causationId === serialized.causationId && message.correlationId === serialized.correlationId && message.executedUser === serialized.executedUser;
+  if (!allNull && !allSerialized) {
+    throw new CanonicalEventIdentityConflictError("cosmos", message.eventId, "Cosmos import metadata must be all null or serialized constants");
+  }
+  return {
+    causationId: message.causationId,
+    correlationId: message.correlationId,
+    executedUser: message.executedUser
+  };
+}
+function checkpointFrom(document) {
+  return {
+    serviceId: asString(document.serviceId, "serviceId"),
+    projectionId: asString(document.projectionId, "projectionId"),
+    lastSuid: asString(document.lastSuid, "lastSuid"),
+    stateJson: asString(document.stateJson, "stateJson"),
+    version: asNumber(document.version, "version"),
+    updatedAt: asNumber(document.updatedAt, "updatedAt")
+  };
+}
+function emulatorKeyBytes(key) {
+  const binary = atob(key);
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function base64(value) {
+  const bytes = new Uint8Array(value);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+var CosmosRestClient = class {
+  initialized = false;
+  endpoint;
+  key;
+  database;
+  fetcher;
+  containers;
+  constructor(options) {
+    this.endpoint = options.endpoint.endsWith("/") ? options.endpoint : `${options.endpoint}/`;
+    this.key = options.key;
+    this.database = options.database;
+    this.fetcher = options.fetcher ?? fetch;
+    this.containers = { ...DEFAULT_COSMOS_CONTAINERS, ...options.containers };
+  }
+  async initialize() {
+    if (this.initialized) return;
+    await this.ensureResource("dbs", { id: this.database });
+    for (const container of cosmosContainerDefinitions(this.containers)) {
+      await this.ensureResource(`dbs/${encodeURIComponent(this.database)}/colls`, {
+        id: container.name,
+        partitionKey: { paths: [container.partitionKeyPath], kind: "Hash" }
+      });
+    }
+    this.initialized = true;
+  }
+  async read(container, id, partitionKey) {
+    const response = await this.request(
+      "GET",
+      `dbs/${encodeURIComponent(this.database)}/colls/${encodeURIComponent(container)}/docs/${encodeURIComponent(id)}`,
+      void 0,
+      { "x-ms-documentdb-partitionkey": JSON.stringify([partitionKey]) }
+    );
+    if (response.status === 404) return void 0;
+    if (!response.ok) throw await this.errorFrom(response, "Cosmos document read failed");
+    const document = await response.json();
+    return { document, etag: response.headers.get("etag") ?? void 0 };
+  }
+  async create(container, document, partitionKey) {
+    const response = await this.request(
+      "POST",
+      `dbs/${encodeURIComponent(this.database)}/colls/${encodeURIComponent(container)}/docs`,
+      document,
+      { "x-ms-documentdb-partitionkey": JSON.stringify([partitionKey]) }
+    );
+    if (!response.ok) throw await this.errorFrom(response, "Cosmos document create failed");
+    return { document: await response.json(), etag: response.headers.get("etag") ?? void 0 };
+  }
+  async replace(container, document, partitionKey, etag) {
+    const response = await this.request(
+      "PUT",
+      `dbs/${encodeURIComponent(this.database)}/colls/${encodeURIComponent(container)}/docs/${encodeURIComponent(String(document.id))}`,
+      document,
+      {
+        "x-ms-documentdb-partitionkey": JSON.stringify([partitionKey]),
+        ...etag === void 0 ? {} : { "if-match": etag }
+      }
+    );
+    if (response.status === 412) return false;
+    if (!response.ok) throw await this.errorFrom(response, "Cosmos document replace failed");
+    return true;
+  }
+  async query(container, query, parameters, partitionKey) {
+    const results = [];
+    let continuation;
+    do {
+      const response = await this.request(
+        "POST",
+        `dbs/${encodeURIComponent(this.database)}/colls/${encodeURIComponent(container)}/docs`,
+        { query, parameters },
+        {
+          "x-ms-documentdb-isquery": "true",
+          "content-type": "application/query+json",
+          "x-ms-max-item-count": "1000",
+          ...partitionKey === void 0 ? {} : { "x-ms-documentdb-partitionkey": JSON.stringify([partitionKey]) },
+          ...continuation === void 0 ? {} : { "x-ms-continuation": continuation }
+        }
+      );
+      if (!response.ok) throw await this.errorFrom(response, "Cosmos query failed");
+      const body = await response.json();
+      for (const document of body.Documents ?? []) {
+        results.push({ document, etag: response.headers.get("etag") ?? void 0 });
+      }
+      continuation = response.headers.get("x-ms-continuation") ?? void 0;
+    } while (continuation !== void 0 && continuation.length > 0);
+    return results;
+  }
+  async ensureResource(path, body) {
+    const response = await this.request("POST", path, body);
+    if (response.status !== 201 && response.status !== 409) {
+      throw await this.errorFrom(response, "Cosmos resource initialization failed");
+    }
+  }
+  async request(method, path, body, extraHeaders = {}) {
+    const date = (/* @__PURE__ */ new Date()).toUTCString().toLowerCase();
+    const resourceType = path.includes("/docs/") || path.endsWith("/docs") ? "docs" : path.includes("/colls/") ? "colls" : "dbs";
+    const normalizedPath = path.replace(/^\//, "");
+    const resourceLink = resourceType === "dbs" && method === "POST" && normalizedPath === "dbs" ? "" : resourceType === "colls" && method === "POST" && normalizedPath.endsWith("/colls") ? normalizedPath.slice(0, -"/colls".length) : resourceType === "docs" && normalizedPath.endsWith("/docs") ? normalizedPath.slice(0, -"/docs".length) : normalizedPath;
+    const signaturePayload = `${method.toLowerCase()}
+${resourceType}
+${resourceLink}
+${date}
+
+`;
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      (() => {
+        const bytes = emulatorKeyBytes(this.key);
+        const buffer = new ArrayBuffer(bytes.byteLength);
+        new Uint8Array(buffer).set(bytes);
+        return buffer;
+      })(),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const signature = encodeURIComponent(`type=master&ver=1.0&sig=${base64(await crypto.subtle.sign("HMAC", cryptoKey, new TextEncoder().encode(signaturePayload)))}`);
+    const response = await this.fetcher(new URL(path, this.endpoint), {
+      method,
+      headers: {
+        accept: "application/json",
+        "content-type": "application/json",
+        "x-ms-date": date,
+        "x-ms-version": "2018-12-31",
+        authorization: signature,
+        ...extraHeaders
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    return response;
+  }
+  async errorFrom(response, prefix) {
+    return new CosmosClientError(response.status, `${prefix} (HTTP ${response.status})`);
+  }
+};
+var CosmosEventStore = class {
+  initialized = false;
+  client;
+  containers;
+  beforeWrite;
+  constructor(options) {
+    if (options.client !== void 0) {
+      this.client = options.client;
+    } else {
+      if (options.endpoint === void 0 || options.key === void 0 || options.database === void 0) {
+        throw new Error("Cosmos endpoint, key, and database are required for the Cosmos store");
+      }
+      this.client = new CosmosRestClient({
+        endpoint: options.endpoint,
+        key: options.key,
+        database: options.database,
+        fetcher: options.fetcher,
+        containers: options.containers
+      });
+    }
+    this.containers = { ...DEFAULT_COSMOS_CONTAINERS, ...options.containers };
+    this.beforeWrite = options.beforeWrite;
+  }
+  async initialize() {
+    if (this.initialized) return;
+    await this.client.initialize();
+    this.initialized = true;
+  }
+  async recordDelivery(message, arrivedAt, deliverySource = "queue") {
+    this.ready();
+    const identity = resolveDeliveryIdentity(message, deliverySource);
+    assertSortableUniqueId(message.suid);
+    const acceptsImportedId = deliverySource === "import";
+    if (!(acceptsImportedId ? isRfc4122Uuid(message.eventId) : isUuidV7(message.eventId))) {
+      throw new CanonicalEventIdentityConflictError(
+        "cosmos",
+        message.eventId,
+        `Cosmos EventId must be an ${acceptsImportedId ? "RFC 4122 UUID" : "UUID v7"}`
+      );
+    }
+    try {
+      JSON.parse(message.payload);
+    } catch {
+      throw new CanonicalEventIdentityConflictError("cosmos", message.eventId, "Cosmos Payload must be UTF-8 JSON text");
+    }
+    assertUtcTimestamp(message.timestamp ?? new Date(arrivedAt).toISOString(), message.eventId);
+    const metadata = metadataForDelivery(message, deliverySource);
+    const lagMs = Math.max(0, arrivedAt - message.enqueuedAt);
+    const eventTags = [...message.eventTags];
+    const binding = await this.readLineageBinding(message.serviceId);
+    if (binding !== void 0 && binding.document.allocatorLineageId !== message.allocatorLineageId) {
+      const incident = {
+        serviceId: message.serviceId,
+        identityKey: lineageIdentity(message.serviceId, binding.document.allocatorLineageId, message.allocatorLineageId),
+        classification: "LINEAGE_MISMATCH",
+        boundLineageId: binding.document.allocatorLineageId,
+        incomingLineageId: message.allocatorLineageId,
+        observedAt: arrivedAt
+      };
+      await this.persistIncident(incident);
+      return { outcome: "lineage-mismatch", kind: "lineage-mismatch", incident };
+    }
+    if (binding === void 0) {
+      await this.bindLineage(message.serviceId, message.allocatorLineageId, arrivedAt);
+      const racedBinding = await this.readLineageBinding(message.serviceId);
+      if (racedBinding === void 0) {
+        throw new Error("Cosmos allocator lineage binding was not durable");
+      }
+      if (racedBinding.document.allocatorLineageId !== message.allocatorLineageId) {
+        const incident = {
+          serviceId: message.serviceId,
+          identityKey: lineageIdentity(message.serviceId, racedBinding.document.allocatorLineageId, message.allocatorLineageId),
+          classification: "LINEAGE_MISMATCH",
+          boundLineageId: racedBinding.document.allocatorLineageId,
+          incomingLineageId: message.allocatorLineageId,
+          observedAt: arrivedAt
+        };
+        await this.persistIncident(incident);
+        return { outcome: "lineage-mismatch", kind: "lineage-mismatch", incident };
+      }
+    }
+    const currentEvents = await this.eventDocuments(message.serviceId);
+    const existingBySuid = currentEvents.find((entry) => entry.document.sortableUniqueId === message.suid);
+    if (existingBySuid !== void 0 && existingBySuid.document.id !== message.eventId) {
+      const incident = {
+        serviceId: message.serviceId,
+        identityKey: collisionIdentity(
+          message.serviceId,
+          message.suid,
+          existingBySuid.document.id,
+          message.eventId
+        ),
+        classification: "SUID_COLLISION",
+        suid: message.suid,
+        existingEventId: existingBySuid.document.id,
+        incomingEventId: message.eventId,
+        observedAt: arrivedAt
+      };
+      await this.persistIncident(incident);
+      return { outcome: "suid-collision", kind: "suid-collision", incident };
+    }
+    const reservedEventId = await this.reserveSuid(message.serviceId, message.suid, message.eventId);
+    if (reservedEventId !== void 0 && reservedEventId !== message.eventId) {
+      const incident = {
+        serviceId: message.serviceId,
+        identityKey: collisionIdentity(message.serviceId, message.suid, reservedEventId, message.eventId),
+        classification: "SUID_COLLISION",
+        suid: message.suid,
+        existingEventId: reservedEventId,
+        incomingEventId: message.eventId,
+        observedAt: arrivedAt
+      };
+      await this.persistIncident(incident);
+      return { outcome: "suid-collision", kind: "suid-collision", incident };
+    }
+    const currentHead = currentEvents.reduce((head, entry) => head === void 0 || compareCosmosSuid(entry.document.sortableUniqueId, head) > 0 ? entry.document.sortableUniqueId : head, void 0);
+    const recoveryBacklogSample = currentHead !== void 0 && compareCosmosSuid(message.suid, currentHead) < 0;
+    const event = await this.mutateEvent(message, eventTags, identity.key, message.timestamp ?? new Date(arrivedAt).toISOString(), metadata);
+    const ops = await this.mutateEventOps(message, arrivedAt, lagMs);
+    if (!recoveryBacklogSample && deliverySource !== "fast") await this.updateLag(message.serviceId, lagMs, arrivedAt);
+    return { outcome: "stored", kind: "stored", event: eventFrom(event, ops) };
+  }
+  async readAllEvents(serviceId, since) {
+    this.ready();
+    if (since.length !== 0) assertSortableUniqueId(since);
+    const documents = await this.eventDocuments(serviceId);
+    const events = await Promise.all(documents.map(async (entry) => eventFrom(entry.document, await this.eventOps(serviceId, entry.document.id))));
+    return events.filter((event) => compareCosmosSuid(event.suid, since) > 0).sort((left, right) => compareCosmosSuid(left.suid, right.suid) || binaryCompare(left.eventId, right.eventId));
+  }
+  async currentLagBound(serviceId, nowMs) {
+    this.ready();
+    const row = await this.client.read(this.containers.lagEstimates, serviceId, serviceId);
+    if (row === void 0) return 0;
+    const estimate = asNumber(row.document.estimateMs, "estimateMs");
+    const observedAt = asNumber(row.document.observedAt, "observedAt");
+    const decayNow = nowMs !== void 0 && nowMs >= 1e11 && observedAt >= 1e11 ? nowMs : observedAt;
+    return decayedLagEstimateMs(estimate, observedAt, decayNow);
+  }
+  async listProjectionTags(serviceId) {
+    this.ready();
+    const tags = /* @__PURE__ */ new Set();
+    for (const entry of await this.eventDocuments(serviceId)) {
+      for (const tag of asStringArray(entry.document.tags, "tags")) tags.add(tag);
+    }
+    return [...tags].sort(binaryCompare);
+  }
+  async readProjectionCheckpoint(serviceId, projectionId) {
+    this.ready();
+    const row = await this.client.read(this.containers.checkpoints, safeId(projectionId), serviceId);
+    return row === void 0 ? void 0 : checkpointFrom(row.document);
+  }
+  async advanceProjectionCheckpoint(input) {
+    this.ready();
+    const id = safeId(input.projectionId);
+    const document = {
+      id,
+      serviceId: input.serviceId,
+      projectionId: input.projectionId,
+      lastSuid: input.lastSuid,
+      stateJson: input.stateJson,
+      version: input.version,
+      updatedAt: input.updatedAt
+    };
+    const existing = await this.client.read(this.containers.checkpoints, id, input.serviceId);
+    if (existing === void 0) {
+      if (input.expectedLastSuid !== null) return false;
+      await this.beforeWrite?.("checkpoint");
+      try {
+        await this.client.create(this.containers.checkpoints, document, input.serviceId);
+        return true;
+      } catch (error) {
+        if (isStatus(error, 409)) return false;
+        throw error;
+      }
+    }
+    if (existing.document.lastSuid !== input.expectedLastSuid) return false;
+    await this.beforeWrite?.("checkpoint");
+    return this.client.replace(this.containers.checkpoints, document, input.serviceId, existing.etag);
+  }
+  async projectionLag(serviceId, projectionId, tag) {
+    this.ready();
+    const checkpoint = await this.readProjectionCheckpoint(serviceId, projectionId);
+    const checkpointSuid = checkpoint?.lastSuid ?? "";
+    const candidates = await this.eventDocuments(serviceId);
+    const matching = (await Promise.all(
+      candidates.map(async (entry) => eventFrom(entry.document, await this.eventOps(serviceId, entry.document.id)))
+    )).filter((event) => event.eventTags.includes(tag));
+    const headSuid = matching.reduce((head, event) => head === "" || compareCosmosSuid(event.suid, head) > 0 ? event.suid : head, "");
+    return {
+      serviceId,
+      projectionId,
+      tag,
+      checkpointSuid,
+      headSuid,
+      behindEvents: matching.filter((event) => compareCosmosSuid(event.suid, checkpointSuid) > 0).length
+    };
+  }
+  async upsertPending(message, firstObservedAt, lagBoundMs) {
+    this.ready();
+    const id = safeId(message.eventId);
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const existing = await this.client.read(this.containers.pendingArrivals, id, message.serviceId);
+      if (existing === void 0) {
+        const document2 = {
+          id,
+          serviceId: message.serviceId,
+          eventId: message.eventId,
+          attemptId: message.attemptId,
+          suid: message.suid,
+          expectedPaths: sortedUnique(message.eventTags),
+          observedPaths: [message.tag],
+          firstObservedAt,
+          lagBoundMs
+        };
+        await this.beforeWrite?.("pending");
+        try {
+          await this.client.create(this.containers.pendingArrivals, document2, message.serviceId);
+          return pendingFrom(document2);
+        } catch (error) {
+          if (isStatus(error, 409)) continue;
+          throw error;
+        }
+      }
+      const pending = pendingFrom(existing.document);
+      if (pending.attemptId !== message.attemptId || pending.suid !== message.suid) {
+        throw new Error(`EventId ${message.eventId} has contradictory pending-arrival identity`);
+      }
+      const document = {
+        ...existing.document,
+        expectedPaths: sortedUnique([...pending.expectedPaths, ...message.eventTags]),
+        observedPaths: sortedUnique([...pending.observedPaths, message.tag]),
+        lagBoundMs: Math.max(pending.lagBoundMs, lagBoundMs)
+      };
+      await this.beforeWrite?.("pending");
+      if (await this.client.replace(this.containers.pendingArrivals, document, message.serviceId, existing.etag)) {
+        return pendingFrom(document);
+      }
+    }
+    throw new Error("Cosmos pending-arrival CAS did not converge");
+  }
+  async listPending(serviceId) {
+    this.ready();
+    const rows = await this.client.query(
+      this.containers.pendingArrivals,
+      serviceId === void 0 ? "SELECT * FROM c" : "SELECT * FROM c WHERE c.serviceId = @serviceId",
+      serviceId === void 0 ? [] : [{ name: "@serviceId", value: serviceId }],
+      serviceId
+    );
+    return rows.map((row) => pendingFrom(row.document)).sort((left, right) => binaryCompare(left.serviceId, right.serviceId) || binaryCompare(left.eventId, right.eventId));
+  }
+  async appendFinding(finding) {
+    this.ready();
+    const document = {
+      id: safeId(finding.eventId, finding.path, finding.classification),
+      ...finding
+    };
+    await this.beforeWrite?.("finding");
+    try {
+      await this.client.create(this.containers.findings, document, finding.serviceId);
+    } catch (error) {
+      if (!isStatus(error, 409)) throw error;
+    }
+  }
+  async appendDeliveryIncident(incident) {
+    this.ready();
+    await this.persistIncident(incident);
+    await this.projectIncident(incident);
+  }
+  async hasDeliveryIncident(serviceId, identityKey) {
+    this.ready();
+    return await this.client.read(
+      this.containers.events,
+      safeId("incident", identityKey),
+      auxiliaryPk(serviceId)
+    ) !== void 0;
+  }
+  async listDeliveryIncidents(serviceId) {
+    this.ready();
+    const rows = await this.client.query(
+      this.containers.events,
+      serviceId === void 0 ? "SELECT * FROM c" : "SELECT * FROM c WHERE c.serviceId = @serviceId",
+      serviceId === void 0 ? [] : [{ name: "@serviceId", value: serviceId }]
+    );
+    return rows.filter((row) => row.document.kind === "delivery-incident").map((row) => incidentFrom(row.document)).sort((left, right) => left.observedAt - right.observedAt || binaryCompare(left.identityKey, right.identityKey));
+  }
+  /** Retryable async projection from the same-partition incident landing. */
+  async projectDeliveryIncidents(serviceId) {
+    const incidents = await this.listDeliveryIncidents(serviceId);
+    let projected = 0;
+    for (const incident of incidents) {
+      await this.projectIncident(incident);
+      projected += 1;
+    }
+    return projected;
+  }
+  async readLineageBinding(serviceId) {
+    return this.client.read(
+      this.containers.events,
+      safeId("allocator-lineage-binding"),
+      auxiliaryPk(serviceId)
+    );
+  }
+  async bindLineage(serviceId, allocatorLineageId, boundAt) {
+    const document = {
+      id: safeId("allocator-lineage-binding"),
+      pk: auxiliaryPk(serviceId),
+      serviceId,
+      kind: "allocator-lineage-binding",
+      allocatorLineageId,
+      boundAt
+    };
+    try {
+      await this.client.create(this.containers.events, document, auxiliaryPk(serviceId));
+    } catch (error) {
+      if (!isStatus(error, 409)) throw error;
+    }
+  }
+  /**
+   * Cosmos has no cross-document unique index. A same-partition SUID binding
+   * is the equivalent guard: the first EventId reserves the opaque SUID and
+   * every later delivery reuses or rejects that reservation before event
+   * mutation. Historical rows are still checked by eventDocuments above.
+   */
+  async reserveSuid(serviceId, suid, eventId) {
+    const id = safeId("suid-binding", suid);
+    const existing = await this.client.read(this.containers.events, id, auxiliaryPk(serviceId));
+    if (existing !== void 0) return existing.document.eventId;
+    const document = {
+      id,
+      pk: auxiliaryPk(serviceId),
+      serviceId,
+      kind: "suid-binding",
+      suid,
+      eventId
+    };
+    await this.beforeWrite?.("event");
+    try {
+      await this.client.create(this.containers.events, document, auxiliaryPk(serviceId));
+      return eventId;
+    } catch (error) {
+      if (!isStatus(error, 409)) throw error;
+      const raced = await this.client.read(this.containers.events, id, auxiliaryPk(serviceId));
+      return raced?.document.eventId;
+    }
+  }
+  async persistIncident(incident) {
+    const document = {
+      id: safeId("incident", incident.identityKey),
+      pk: auxiliaryPk(incident.serviceId),
+      serviceId: incident.serviceId,
+      kind: "delivery-incident",
+      identityKey: incident.identityKey,
+      classification: incident.classification,
+      ...incident.suid === void 0 ? {} : { suid: incident.suid },
+      ...incident.existingEventId === void 0 ? {} : { existingEventId: incident.existingEventId },
+      ...incident.incomingEventId === void 0 ? {} : { incomingEventId: incident.incomingEventId },
+      ...incident.eventId === void 0 ? {} : { eventId: incident.eventId },
+      ...incident.boundLineageId === void 0 ? {} : { boundLineageId: incident.boundLineageId },
+      ...incident.incomingLineageId === void 0 ? {} : { incomingLineageId: incident.incomingLineageId },
+      observedAt: incident.observedAt
+    };
+    await this.beforeWrite?.("incident");
+    try {
+      await this.client.create(this.containers.events, document, auxiliaryPk(incident.serviceId));
+    } catch (error) {
+      if (!isStatus(error, 409)) throw error;
+    }
+  }
+  async projectIncident(incident) {
+    const document = {
+      id: safeId("incident", incident.identityKey),
+      serviceId: incident.serviceId,
+      eventId: incident.eventId ?? incident.incomingEventId ?? incident.identityKey,
+      path: incident.classification,
+      classification: incident.classification,
+      firstObservedAt: incident.observedAt,
+      lagBoundMs: 0,
+      observedAt: incident.observedAt,
+      kind: "delivery-incident",
+      identityKey: incident.identityKey
+    };
+    await this.beforeWrite?.("incident-projection");
+    try {
+      await this.client.create(this.containers.findings, document, incident.serviceId);
+    } catch (error) {
+      if (!isStatus(error, 409)) throw error;
+    }
+  }
+  async hasFinding(serviceId, eventId, path, classification) {
+    this.ready();
+    return await this.client.read(
+      this.containers.findings,
+      safeId(eventId, path, classification),
+      serviceId
+    ) !== void 0;
+  }
+  async listFindings(serviceId, eventId) {
+    this.ready();
+    const predicates = [];
+    const parameters = [];
+    if (serviceId !== void 0) {
+      predicates.push("c.serviceId = @serviceId");
+      parameters.push({ name: "@serviceId", value: serviceId });
+    }
+    if (eventId !== void 0) {
+      predicates.push("c.eventId = @eventId");
+      parameters.push({ name: "@eventId", value: eventId });
+    }
+    const rows = await this.client.query(
+      this.containers.findings,
+      `SELECT * FROM c${predicates.length === 0 ? "" : ` WHERE ${predicates.join(" AND ")}`}`,
+      parameters,
+      serviceId
+    );
+    return rows.filter((row) => row.document.kind === void 0).map((row) => findingFrom(row.document)).sort((left, right) => left.observedAt - right.observedAt || binaryCompare(left.eventId, right.eventId) || binaryCompare(left.path, right.path));
+  }
+  async eventDocuments(serviceId) {
+    const rows = await this.client.query(
+      this.containers.events,
+      "SELECT * FROM c WHERE c.serviceId = @serviceId AND IS_DEFINED(c.sortableUniqueId)",
+      [{ name: "@serviceId", value: serviceId }]
+    );
+    return rows;
+  }
+  async eventOps(serviceId, eventId) {
+    const row = await this.client.read(
+      this.containers.events,
+      safeId("event-ops", eventId),
+      eventPk(serviceId, eventId)
+    );
+    return row?.document;
+  }
+  async mutateEvent(message, eventTags, eventType, timestamp, metadata) {
+    const id = message.eventId;
+    const pk = eventPk(message.serviceId, id);
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const existing = await this.client.read(this.containers.events, id, pk);
+      if (existing === void 0) {
+        const document = {
+          id,
+          pk,
+          serviceId: message.serviceId,
+          sortableUniqueId: message.suid,
+          eventType,
+          payload: message.payload,
+          tags: eventTags,
+          timestamp,
+          causationId: metadata.causationId,
+          correlationId: metadata.correlationId,
+          executedUser: metadata.executedUser
+        };
+        await this.beforeWrite?.("event");
+        try {
+          await this.client.create(this.containers.events, document, pk);
+          return document;
+        } catch (error) {
+          if (isStatus(error, 409)) continue;
+          throw error;
+        }
+      }
+      const prior = eventFrom(existing.document);
+      if (prior.eventType !== eventType) {
+        throw new CanonicalEventIdentityConflictError("cosmos", message.eventId);
+      }
+      if (prior.suid !== message.suid || prior.payload !== message.payload || JSON.stringify(prior.eventTags) !== JSON.stringify(eventTags) || prior.timestamp !== timestamp || prior.causationId !== metadata.causationId || prior.correlationId !== metadata.correlationId || prior.executedUser !== metadata.executedUser) {
+        throw new Error(`EventId ${message.eventId} conflicts with its durable Cosmos row`);
+      }
+      return existing.document;
+    }
+    throw new Error("Cosmos event CAS did not converge");
+  }
+  async mutateEventOps(message, arrivedAt, lagMs) {
+    const id = safeId("event-ops", message.eventId);
+    const pk = eventPk(message.serviceId, message.eventId);
+    const nextArrival = {
+      serviceId: message.serviceId,
+      eventId: message.eventId,
+      tag: message.tag,
+      enqueuedAt: message.enqueuedAt,
+      arrivedAt,
+      lagMs
+    };
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const existing = await this.client.read(this.containers.events, id, pk);
+      if (existing === void 0) {
+        const document2 = {
+          id,
+          pk,
+          serviceId: message.serviceId,
+          kind: "event-ops",
+          eventId: message.eventId,
+          attemptId: message.attemptId,
+          allocatorLineageId: message.allocatorLineageId,
+          firstArrivedAt: arrivedAt,
+          lastArrivedAt: arrivedAt,
+          maxDeliveryLagMs: lagMs,
+          arrivals: [nextArrival]
+        };
+        await this.beforeWrite?.("event");
+        try {
+          await this.client.create(this.containers.events, document2, pk);
+          return document2;
+        } catch (error) {
+          if (isStatus(error, 409)) continue;
+          throw error;
+        }
+      }
+      if (existing.document.allocatorLineageId !== message.allocatorLineageId) {
+        throw new CanonicalEventIdentityConflictError("cosmos", message.eventId, "Cosmos event sidecar lineage conflicts");
+      }
+      const arrivals = [...existing.document.arrivals];
+      const index = arrivals.findIndex((arrival) => arrival.tag === message.tag);
+      if (index < 0) arrivals.push(nextArrival);
+      else {
+        const prior = arrivals[index];
+        arrivals[index] = {
+          ...prior,
+          enqueuedAt: Math.min(prior.enqueuedAt, nextArrival.enqueuedAt),
+          arrivedAt: Math.max(prior.arrivedAt, nextArrival.arrivedAt),
+          lagMs: Math.max(prior.lagMs, nextArrival.lagMs)
+        };
+      }
+      const document = {
+        ...existing.document,
+        firstArrivedAt: Math.min(existing.document.firstArrivedAt, arrivedAt),
+        lastArrivedAt: Math.max(existing.document.lastArrivedAt, arrivedAt),
+        maxDeliveryLagMs: Math.max(existing.document.maxDeliveryLagMs, lagMs),
+        arrivals
+      };
+      await this.beforeWrite?.("event");
+      if (await this.client.replace(this.containers.events, document, pk, existing.etag)) return document;
+    }
+    throw new Error("Cosmos event sidecar CAS did not converge");
+  }
+  async updateLag(serviceId, lagMs, observedAt) {
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const existing = await this.client.read(this.containers.lagEstimates, serviceId, serviceId);
+      const currentEstimate = existing === void 0 ? 0 : decayedLagEstimateMs(asNumber(existing.document.estimateMs, "estimateMs"), asNumber(existing.document.observedAt, "observedAt"), observedAt);
+      const document = {
+        id: serviceId,
+        serviceId,
+        estimateMs: Math.max(currentEstimate, lagMs),
+        observedAt
+      };
+      await this.beforeWrite?.("lag");
+      if (existing === void 0) {
+        try {
+          await this.client.create(this.containers.lagEstimates, document, serviceId);
+          return;
+        } catch (error) {
+          if (isStatus(error, 409)) continue;
+          throw error;
+        }
+      } else if (await this.client.replace(this.containers.lagEstimates, document, serviceId, existing.etag)) {
+        return;
+      }
+    }
+    throw new Error("Cosmos lag estimate CAS did not converge");
+  }
+  ready() {
+    if (!this.initialized) throw new Error("CosmosEventStore.initialize() must complete before use");
+  }
+};
+
+// src/bootstrap/manifest.ts
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canonical = (value) => {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isObject(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+};
+function bootstrapDigest(value) {
+  let hash = 2166136261;
+  for (const char of canonical(value)) {
+    hash ^= char.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+// src/tag/EventDigest.ts
+var EVENT_DIGEST_DOMAIN_SEPARATOR = "sekiban-dcb-ts/eventDigest/v2";
+var EventDigestValidationError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "EventDigestValidationError";
+  }
+};
+var encoder = new TextEncoder();
+var requiredFieldNames = [
+  "serviceId",
+  "eventId",
+  "sortableUniqueId",
+  "eventType",
+  "timestamp",
+  "attemptId",
+  "declaredTagSet",
+  "payload"
+];
+var optionalFieldNames = ["allocatorLineageId"];
+var excludedFieldNames = ["causationId", "correlationId", "executedUser"];
+var allowedFieldNames = /* @__PURE__ */ new Set([...requiredFieldNames, ...optionalFieldNames, ...excludedFieldNames]);
+function byteCompare(left, right) {
+  const length = Math.min(left.byteLength, right.byteLength);
+  for (let index = 0; index < length; index += 1) {
+    const delta = left[index] - right[index];
+    if (delta !== 0) return delta;
+  }
+  return left.byteLength - right.byteLength;
+}
+function concat(parts) {
+  const length = parts.reduce((total, part) => total + part.byteLength, 0);
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const part of parts) {
+    bytes.set(part, offset);
+    offset += part.byteLength;
+  }
+  return bytes;
+}
+function lengthPrefix(length) {
+  if (!Number.isSafeInteger(length) || length < 0 || length > 4294967295) {
+    throw new EventDigestValidationError("eventDigest field length is outside uint32 range");
+  }
+  return Uint8Array.of(
+    length >>> 24 & 255,
+    length >>> 16 & 255,
+    length >>> 8 & 255,
+    length & 255
+  );
+}
+function utf8(value) {
+  return encoder.encode(value);
+}
+function hasOwn(input, name) {
+  return Object.prototype.hasOwnProperty.call(input, name);
+}
+function requiredUtf8(input, name) {
+  const value = input[name];
+  if (typeof value !== "string") {
+    throw new EventDigestValidationError(`eventDigest required field ${name} is absent or not a string`);
+  }
+  return utf8(value);
+}
+function tagSetBytes(tags) {
+  const canonical2 = canonicalDeclaredTagSet(tags);
+  return concat(canonical2.map((tag) => {
+    const bytes = utf8(tag);
+    return concat([lengthPrefix(bytes.byteLength), bytes]);
+  }));
+}
+function canonicalDeclaredTagSet(tags) {
+  if (!Array.isArray(tags) || !tags.every((tag) => typeof tag === "string")) {
+    throw new EventDigestValidationError("eventDigest declaredTagSet must contain only strings");
+  }
+  const encoded = tags.map((tag) => ({ tag, bytes: utf8(tag) })).sort((left, right) => byteCompare(left.bytes, right.bytes));
+  const unique = [];
+  let previous;
+  for (const item of encoded) {
+    if (previous !== void 0 && byteCompare(previous, item.bytes) === 0) continue;
+    unique.push(item.tag);
+    previous = item.bytes;
+  }
+  return Object.freeze(unique);
+}
+function assertClosedProjection(input) {
+  for (const name of Object.keys(input)) {
+    if (!allowedFieldNames.has(name)) {
+      throw new EventDigestValidationError(`eventDigest field ${name} is neither included nor explicitly excluded`);
+    }
+  }
+  for (const name of requiredFieldNames) {
+    if (!hasOwn(input, name)) {
+      throw new EventDigestValidationError(`eventDigest required field ${name} is absent`);
+    }
+  }
+  if (!Array.isArray(input.declaredTagSet)) {
+    throw new EventDigestValidationError("eventDigest required field declaredTagSet is absent or invalid");
+  }
+  if (!(input.payload instanceof Uint8Array)) {
+    throw new EventDigestValidationError("eventDigest required field payload is absent or not raw bytes");
+  }
+  if (hasOwn(input, "allocatorLineageId") && typeof input.allocatorLineageId !== "string") {
+    throw new EventDigestValidationError("eventDigest optional field allocatorLineageId must be absent or a string");
+  }
+}
+function encodeField(name, value) {
+  const nameBytes = utf8(name);
+  const present = value === void 0 ? Uint8Array.of(0) : Uint8Array.of(1);
+  const valueBytes = value ?? new Uint8Array();
+  return concat([
+    present,
+    lengthPrefix(nameBytes.byteLength),
+    nameBytes,
+    lengthPrefix(valueBytes.byteLength),
+    valueBytes
+  ]);
+}
+function eventDigestBytes(input) {
+  assertClosedProjection(input);
+  const fields = [
+    ["serviceId", requiredUtf8(input, "serviceId")],
+    ["eventId", requiredUtf8(input, "eventId")],
+    ["sortableUniqueId", requiredUtf8(input, "sortableUniqueId")],
+    ["eventType", requiredUtf8(input, "eventType")],
+    ["timestamp", requiredUtf8(input, "timestamp")],
+    ["allocatorLineageId", hasOwn(input, "allocatorLineageId") ? utf8(input.allocatorLineageId) : void 0],
+    ["attemptId", requiredUtf8(input, "attemptId")],
+    ["declaredTagSet", tagSetBytes(input.declaredTagSet)],
+    ["payload", input.payload]
+  ];
+  return concat([
+    utf8(EVENT_DIGEST_DOMAIN_SEPARATOR),
+    Uint8Array.of(0),
+    ...fields.map(([name, value]) => encodeField(name, value))
+  ]);
+}
+async function eventDigestHex(input) {
+  const bytes = eventDigestBytes(input);
+  const source = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  const digest = await crypto.subtle.digest("SHA-256", source);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// src/bootstrap/BootstrapStoreAdapter.ts
+function arrayBufferBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+var BootstrapIdentityConflictError = class extends Error {
+  constructor(provider, eventId) {
+    super(`${provider} bootstrap EventId ${eventId} conflicts with the target identity`);
+    this.provider = provider;
+    this.eventId = eventId;
+    this.name = "BootstrapIdentityConflictError";
+  }
+  provider;
+  eventId;
+  code = "BOOTSTRAP_EVENT_IDENTITY_CONFLICT";
+};
+function compareOpaque(left, right) {
+  const a = new TextEncoder().encode(left);
+  const b = new TextEncoder().encode(right);
+  for (let index = 0; index < Math.min(a.length, b.length); index += 1) if (a[index] !== b[index]) return a[index] - b[index];
+  return a.length - b.length;
+}
+function bootstrapEventIdentityMatches(event, record) {
+  return event.suid === record.suid && event.payload === record.payload && event.eventType === record.eventType && event.timestamp === record.timestamp && event.causationId === record.causationId && event.correlationId === record.correlationId && event.executedUser === record.executedUser && JSON.stringify(event.eventTags) === JSON.stringify(record.eventTags);
+}
+function toRecord(event) {
+  return {
+    eventId: event.eventId,
+    suid: event.suid,
+    payload: event.payload,
+    eventTags: [...event.eventTags],
+    eventType: event.eventType,
+    provenance: { origin: "g32" },
+    timestamp: event.timestamp,
+    causationId: event.causationId,
+    correlationId: event.correlationId,
+    executedUser: event.executedUser
+  };
+}
+var BootstrapStoreAdapter = class {
+  constructor(provider, store, identityGuard = bootstrapEventIdentityMatches) {
+    this.provider = provider;
+    this.store = store;
+    this.identityGuard = identityGuard;
+  }
+  provider;
+  store;
+  identityGuard;
+  async exportPage(input) {
+    if (!Number.isSafeInteger(input.pageSize) || input.pageSize <= 0) throw new Error("bootstrap export pageSize must be positive");
+    await this.store.initialize();
+    const observed = await this.store.readAllEvents(input.sourceServiceId, "");
+    const highWatermark = input.cursor?.highWatermark ?? observed.at(-1)?.suid ?? null;
+    const snapshot = observed.filter((event) => highWatermark === null || compareOpaque(event.suid, highWatermark) <= 0).map(toRecord);
+    const start = input.cursor?.nextEventId === null || input.cursor?.nextEventId === void 0 ? 0 : snapshot.findIndex((event) => event.eventId === input.cursor.nextEventId) + 1;
+    const page = snapshot.slice(Math.max(0, start), Math.max(0, start) + input.pageSize);
+    const tagCounts = {};
+    for (const event of snapshot) for (const tag of event.eventTags) tagCounts[tag] = (tagCounts[tag] ?? 0) + 1;
+    const draft = {
+      format: "sekiban-dcb-bootstrap",
+      version: 1,
+      source: { serviceId: input.sourceServiceId, lineageId: input.sourceAllocatorLineageId },
+      target: { serviceId: input.targetServiceId, allocatorLineageId: input.allocatorLineageId },
+      highWatermark,
+      eventCount: snapshot.length,
+      tagCounts,
+      canonicalization: "utf8-json-sorted-keys-v1"
+    };
+    const fullDump = { manifest: { ...draft, contentDigest: "" }, events: snapshot };
+    const manifest = { ...draft, contentDigest: bootstrapDigest(fullDump) };
+    const pageEnd = Math.max(0, start) + page.length;
+    return {
+      dump: { manifest, events: snapshot },
+      page,
+      cursor: { highWatermark, nextEventId: pageEnd >= snapshot.length ? null : snapshot[pageEnd - 1].eventId },
+      complete: pageEnd >= snapshot.length
+    };
+  }
+  async admitBootstrap(input) {
+    await this.store.initialize();
+    const existing = new Map((await this.store.readAllEvents(input.manifest.target.serviceId, "")).map((event) => [event.eventId, event]));
+    for (const record of input.events) {
+      const prior = existing.get(record.eventId);
+      if (prior !== void 0 && !this.identityGuard(prior, record)) throw new BootstrapIdentityConflictError(this.provider, record.eventId);
+      for (const tag of record.eventTags) {
+        const attemptId = `bootstrap:${input.importId}:${input.leaseEpoch}`;
+        const digestInput = {
+          serviceId: input.manifest.target.serviceId,
+          eventId: record.eventId,
+          sortableUniqueId: record.suid,
+          eventType: record.eventType,
+          timestamp: record.timestamp,
+          allocatorLineageId: input.manifest.target.allocatorLineageId,
+          attemptId,
+          declaredTagSet: canonicalDeclaredTagSet(record.eventTags),
+          payload: new TextEncoder().encode(record.payload)
+        };
+        const delivered = await this.store.recordDelivery({
+          version: 1,
+          serviceId: input.manifest.target.serviceId,
+          allocatorLineageId: input.manifest.target.allocatorLineageId,
+          tag,
+          attemptId,
+          eventId: record.eventId,
+          suid: record.suid,
+          payload: record.payload,
+          eventTags: [...record.eventTags],
+          eventType: record.eventType,
+          provenance: "g32",
+          timestamp: record.timestamp,
+          causationId: record.causationId,
+          correlationId: record.correlationId,
+          executedUser: record.executedUser,
+          enqueuedAt: 0,
+          completeness: {
+            canonicalBytesBase64: arrayBufferBase64(eventDigestBytes(digestInput)),
+            eventDigest: await eventDigestHex(digestInput),
+            declaredTagSet: [...digestInput.declaredTagSet],
+            localCommittedMembership: [{ serviceId: input.manifest.target.serviceId, eventId: record.eventId, tag }],
+            // Bootstrap is not a source outbox replay path. The deterministic
+            // per-event/tag ordinal is only enough to satisfy the D1 receipt
+            // key while G44's source scanner remains explicitly out of scope.
+            obligationSequence: Math.max(1, [...new TextEncoder().encode(`${record.eventId}|${tag}`)].reduce((total, byte) => (total * 33 + byte) % 1e9, 5381))
+          }
+          // A C# import may contain a historical RFC 4122 Id. It bypasses
+          // Queue/doorbell and is admitted only through this fenced path;
+          // normal deliveries still require UUID v7.
+        }, 0, "import");
+        if (delivered.outcome !== "stored") throw new Error(`${this.provider} bootstrap admission rejected ${record.eventId}`);
+      }
+    }
+  }
+  async verifyBootstrap(input) {
+    await this.store.initialize();
+    const actual = await this.store.readAllEvents(input.manifest.target.serviceId, "");
+    if (actual.length !== input.manifest.eventCount) throw new Error(`${this.provider} bootstrap store count differs for ${input.importId}`);
+  }
+};
+function createBootstrapStoreAdapter(provider, store, identityGuard) {
+  return new BootstrapStoreAdapter(provider, store, identityGuard);
+}
+
+// src/cosmos.ts
+function createCosmosStoreProvider(config) {
+  return Object.freeze({
+    name: "cosmos",
+    isConfigured: () => true,
+    create: () => new CosmosEventStore(config),
+    createBootstrapAdapter: () => createCosmosBootstrapAdapter(new CosmosEventStore(config))
+  });
+}
+function createCosmosBootstrapAdapter(store) {
+  return createBootstrapStoreAdapter("cosmos", store, (event, record) => bootstrapEventIdentityMatches(event, record));
+}
+export {
+  CosmosClientError,
+  CosmosEventStore,
+  CosmosRestClient,
+  DEFAULT_COSMOS_CONTAINERS,
+  compareCosmosSuid,
+  createCosmosBootstrapAdapter,
+  createCosmosStoreProvider
+};