@ensnode/ensnode-sdk 0.0.0-next-20260211102546 → 0.0.0-next-20260213092129

package/dist/index.cjs

@@ -230,7 +230,6 @@ __export(index_exports, {
   serializeChainId: () => serializeChainId,
   serializeChainIndexingSnapshots: () => serializeChainIndexingSnapshots,
   serializeConfigResponse: () => serializeConfigResponse,
-  serializeCrossChainIndexingStatusSnapshotOmnichain: () => serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime: () => serializeDatetime,
   serializeDomainAssetId: () => serializeDomainAssetId,
   serializeENSApiPublicConfig: () => serializeENSApiPublicConfig,
@@ -1132,20 +1131,205 @@ function sortChainStatusesByStartBlockAsc(chains) {
   );
 }
 
-// src/ensindexer/indexing-status/deserialize.ts
-var import_v410 = require("zod/v4");
+// src/ensindexer/indexing-status/cross-chain-indexing-status-snapshot.ts
+var CrossChainIndexingStrategyIds = {
+  /**
+   * Represents that the indexing of events across all indexed chains will
+   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+   * and block number.
+   *
+   * This strategy is "deterministic" in that the order of processing cross-chain indexed
+   * events and each resulting indexed data state transition recorded in ENSDb is always
+   * the same for each ENSIndexer instance operating with an equivalent
+   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+   * - increased indexing latency that must wait for the slowest indexed chain to
+   *   add new blocks or to discover new blocks through the configured RPCs.
+   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+   *   will be affected.
+   */
+  Omnichain: "omnichain"
+};
+function getLatestIndexedBlockRef(indexingStatus, chainId) {
+  const chainIndexingStatus = indexingStatus.omnichainSnapshot.chains.get(chainId);
+  if (chainIndexingStatus === void 0) {
+    return null;
+  }
+  if (chainIndexingStatus.chainStatus === ChainIndexingStatusIds.Queued) {
+    return null;
+  }
+  return chainIndexingStatus.latestIndexedBlock;
+}
 
-// src/ensindexer/indexing-status/zod-schemas.ts
-var import_v49 = require("zod/v4");
+// src/ensindexer/indexing-status/deserialize/chain-indexing-status-snapshot.ts
+var import_v48 = require("zod/v4");
 
-// src/shared/deserialize.ts
+// src/ensindexer/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
 var import_v47 = require("zod/v4");
+
+// src/shared/block-ref.ts
+function isBefore(blockA, blockB) {
+  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
+}
+function isEqualTo(blockA, blockB) {
+  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
+}
+function isBeforeOrEqualTo(blockA, blockB) {
+  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+}
+
+// src/ensindexer/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
+function invariant_chainSnapshotQueuedBlocks(ctx) {
+  const { config } = ctx.value;
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
+  if (isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotBackfillBlocks(ctx) {
+  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
+    });
+  }
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
+  if (isEqualTo(backfillEndBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`backfillEndBlock` must be the same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotCompletedBlocks(ctx) {
+  const { config, latestIndexedBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotFollowingBlocks(ctx) {
+  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
+    });
+  }
+}
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("configType", [
+  import_v47.z.object({
+    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  import_v47.z.object({
+    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  })
+]);
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v47.z.object({
+  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Queued),
+  config: makeChainIndexingConfigSchema(valueLabel)
+}).check(invariant_chainSnapshotQueuedBlocks);
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v47.z.object({
+  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Backfill),
+  config: makeChainIndexingConfigSchema(valueLabel),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  backfillEndBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotBackfillBlocks);
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v47.z.object({
+  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Completed),
+  config: import_v47.z.object({
+    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotCompletedBlocks);
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v47.z.object({
+  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Following),
+  config: import_v47.z.object({
+    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotFollowingBlocks);
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("chainStatus", [
+  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]);
+var makeSerializedChainIndexingStatusSnapshotSchema = makeChainIndexingStatusSnapshotSchema;
+
+// src/ensindexer/indexing-status/deserialize/chain-indexing-status-snapshot.ts
+function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeSerializedChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into ChainIndexingStatusSnapshot:
+${(0, import_v48.prettifyError)(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/indexing-status/deserialize/cross-chain-indexing-status-snapshot.ts
+var import_v412 = require("zod/v4");
+
+// src/ensindexer/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
+var import_v411 = require("zod/v4");
+
+// src/ensindexer/indexing-status/zod-schema/omnichain-indexing-status-snapshot.ts
+var import_v410 = require("zod/v4");
+
+// src/shared/deserialize.ts
+var import_v49 = require("zod/v4");
 function deserializeChainId(maybeChainId, valueLabel) {
   const schema = makeChainIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeChainId);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ChainId:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1155,7 +1339,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1165,7 +1349,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1175,7 +1359,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1185,7 +1369,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1195,7 +1379,7 @@ function deserializeBlockrange(maybeBlockrange, valueLabel) {
   const parsed = schema.safeParse(maybeBlockrange);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Blockrange:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1205,7 +1389,7 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1215,7 +1399,7 @@ function deserializeDuration(maybeDuration, valueLabel) {
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1225,7 +1409,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1235,7 +1419,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1245,7 +1429,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1255,13 +1439,13 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
-// src/ensindexer/indexing-status/types.ts
+// src/ensindexer/indexing-status/omnichain-indexing-status-snapshot.ts
 var OmnichainIndexingStatusIds = {
   /**
    * Represents that omnichain indexing is not ready to begin yet because
@@ -1288,25 +1472,30 @@ var OmnichainIndexingStatusIds = {
    */
   Completed: "omnichain-completed"
 };
-var CrossChainIndexingStrategyIds = {
-  /**
-   * Represents that the indexing of events across all indexed chains will
-   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
-   * and block number.
-   *
-   * This strategy is "deterministic" in that the order of processing cross-chain indexed
-   * events and each resulting indexed data state transition recorded in ENSDb is always
-   * the same for each ENSIndexer instance operating with an equivalent
-   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
-   * - increased indexing latency that must wait for the slowest indexed chain to
-   *   add new blocks or to discover new blocks through the configured RPCs.
-   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
-   *   will be affected.
-   */
-  Omnichain: "omnichain"
-};
-
-// src/ensindexer/indexing-status/helpers.ts
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
+  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
+  const atLeastOneChainInTargetStatus = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  const otherChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
+  const allChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return allChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
+  const allChainsHaveValidStatuses = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  return allChainsHaveValidStatuses;
+}
 function getOmnichainIndexingStatus(chains) {
   if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
     return OmnichainIndexingStatusIds.Following;
@@ -1336,42 +1525,8 @@ function getOmnichainIndexingCursor(chains) {
   }
   return Math.max(...latestIndexedBlockTimestamps);
 }
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
-  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
-}
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
-  const atLeastOneChainInTargetStatus = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
-  );
-  const otherChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
-  );
-  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
-}
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
-  const allChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
-  );
-  return allChainsHaveValidStatuses;
-}
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
-  const allChainsHaveValidStatuses = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
-  );
-  return allChainsHaveValidStatuses;
-}
-function getLatestIndexedBlockRef(indexingStatus, chainId) {
-  const chainIndexingStatus = indexingStatus.omnichainSnapshot.chains.get(chainId);
-  if (chainIndexingStatus === void 0) {
-    return null;
-  }
-  if (chainIndexingStatus.chainStatus === ChainIndexingStatusIds.Queued) {
-    return null;
-  }
-  return chainIndexingStatus.latestIndexedBlock;
-}
 
-// src/ensindexer/indexing-status/validations.ts
+// src/ensindexer/indexing-status/zod-schema/omnichain-indexing-status-snapshot.ts
 function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
   const snapshot = ctx.value;
   const chains = Array.from(snapshot.chains.values());
@@ -1421,264 +1576,66 @@ function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlo
     });
   }
 }
-function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
-  const snapshot = ctx.value;
-  const indexedChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
-  );
-  if (indexedChains.length === 0) {
-    return;
-  }
-  const indexedChainLatestIndexedBlocks = indexedChains.map(
-    (chain) => chain.latestIndexedBlock.timestamp
-  );
-  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
-  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
-    });
-  }
-}
-function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
-    });
-  }
-}
-function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
-    });
-  }
-}
-function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
-    });
-  }
-}
-function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
-  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
-  const { omnichainIndexingCursor } = omnichainSnapshot;
-  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
-    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
-      slowestChainIndexingCursor,
-      omnichainIndexingCursor
-    });
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
-    });
-  }
-}
-function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
-  const { snapshotTime, omnichainSnapshot } = ctx.value;
-  const chains = Array.from(omnichainSnapshot.chains.values());
-  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
-  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.configType === ChainIndexingConfigTypeIds.Definite).map((chainConfig) => chainConfig.endBlock.timestamp);
-  const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
-  const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
-  const highestKnownBlockTimestamp = Math.max(
-    ...startBlockTimestamps,
-    ...endBlockTimestamps,
-    ...backfillEndBlockTimestamps,
-    ...latestKnownBlockTimestamps
-  );
-  if (snapshotTime < highestKnownBlockTimestamp) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `'snapshotTime' (${snapshotTime}) must be greater than or equal to the "highest known block timestamp" (${highestKnownBlockTimestamp})`
-    });
-  }
-}
-function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
-  const projection = ctx.value;
-  const { snapshot, projectedAt } = projection;
-  if (snapshot.snapshotTime > projectedAt) {
-    ctx.issues.push({
-      code: "custom",
-      input: projection,
-      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
-    });
-  }
-}
-function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
-  const projection = ctx.value;
-  const { projectedAt, snapshot, worstCaseDistance } = projection;
-  const { omnichainSnapshot } = snapshot;
-  const expectedWorstCaseDistance = projectedAt - omnichainSnapshot.omnichainIndexingCursor;
-  if (worstCaseDistance !== expectedWorstCaseDistance) {
-    ctx.issues.push({
-      code: "custom",
-      input: projection,
-      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.omnichainIndexingCursor`."
-    });
-  }
-}
-
-// src/ensindexer/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
-var import_v48 = require("zod/v4");
-
-// src/shared/block-ref.ts
-function isBefore(blockA, blockB) {
-  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
-}
-function isEqualTo(blockA, blockB) {
-  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
-}
-function isBeforeOrEqualTo(blockA, blockB) {
-  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
-}
-
-// src/ensindexer/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
-function invariant_chainSnapshotQueuedBlocks(ctx) {
-  const { config } = ctx.value;
-  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
-    return;
-  }
-  if (isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `config.endBlock`."
-    });
-  }
-}
-function invariant_chainSnapshotBackfillBlocks(ctx) {
-  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
-    });
-  }
-  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
-    });
-  }
-  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
-    return;
-  }
-  if (isEqualTo(backfillEndBlock, config.endBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`backfillEndBlock` must be the same as `config.endBlock`."
-    });
-  }
-}
-function invariant_chainSnapshotCompletedBlocks(ctx) {
-  const { config, latestIndexedBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
+  const snapshot = ctx.value;
+  const indexedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  if (indexedChains.length === 0) {
+    return;
+  }
+  const indexedChainLatestIndexedBlocks = indexedChains.map(
+    (chain) => chain.latestIndexedBlock.timestamp
+  );
+  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
+  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
     ctx.issues.push({
       code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
     });
   }
-  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
+}
+function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
     ctx.issues.push({
       code: "custom",
-      input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
+      input: chains,
+      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
     });
   }
 }
-function invariant_chainSnapshotFollowingBlocks(ctx) {
-  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
     ctx.issues.push({
       code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+      input: chains,
+      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
     });
   }
-  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
+}
+function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
     ctx.issues.push({
       code: "custom",
-      input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
+      input: chains,
+      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
     });
   }
 }
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("configType", [
-  import_v48.z.object({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  import_v48.z.object({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  })
-]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v48.z.object({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Queued),
-  config: makeChainIndexingConfigSchema(valueLabel)
-}).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v48.z.object({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Backfill),
-  config: makeChainIndexingConfigSchema(valueLabel),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  backfillEndBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v48.z.object({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Completed),
-  config: import_v48.z.object({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v48.z.object({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Following),
-  config: import_v48.z.object({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  latestKnownBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("chainStatus", [
-  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
-  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
-]);
-var makeSerializedChainIndexingStatusSnapshotSchema = makeChainIndexingStatusSnapshotSchema;
-
-// src/ensindexer/indexing-status/zod-schemas.ts
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v49.z.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v410.z.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
   error: "Chains indexing statuses must be an object mapping valid chain IDs to their indexing status snapshots."
 }).transform((serializedChainsIndexingStatus) => {
   const chainsIndexingStatus = /* @__PURE__ */ new Map();
@@ -1687,29 +1644,29 @@ var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v49.z.rec
   }
   return chainsIndexingStatus;
 });
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v49.z.strictObject({
-  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Unstarted),
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v410.z.strictObject({
+  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Unstarted),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v49.z.strictObject({
-  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Backfill),
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v410.z.strictObject({
+  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Backfill),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
     (chains) => chains
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v49.z.strictObject({
-  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Completed),
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v410.z.strictObject({
+  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Completed),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v49.z.strictObject({
-  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Following),
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v410.z.strictObject({
+  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Following),
   chains: makeChainIndexingStatusesSchema(valueLabel),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v49.z.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v410.z.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1717,75 +1674,132 @@ var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexin
 ]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
   invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
 ).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v49.z.strictObject({
-  strategy: import_v49.z.literal(CrossChainIndexingStrategyIds.Omnichain),
+
+// src/ensindexer/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
+function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
+  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
+  const { omnichainIndexingCursor } = omnichainSnapshot;
+  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
+    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
+      slowestChainIndexingCursor,
+      omnichainIndexingCursor
+    });
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
+    });
+  }
+}
+function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
+  const { snapshotTime, omnichainSnapshot } = ctx.value;
+  const chains = Array.from(omnichainSnapshot.chains.values());
+  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
+  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.configType === ChainIndexingConfigTypeIds.Definite).map((chainConfig) => chainConfig.endBlock.timestamp);
+  const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
+  const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
+  const highestKnownBlockTimestamp = Math.max(
+    ...startBlockTimestamps,
+    ...endBlockTimestamps,
+    ...backfillEndBlockTimestamps,
+    ...latestKnownBlockTimestamps
+  );
+  if (snapshotTime < highestKnownBlockTimestamp) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'snapshotTime' (${snapshotTime}) must be greater than or equal to the "highest known block timestamp" (${highestKnownBlockTimestamp})`
+    });
+  }
+}
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v411.z.strictObject({
+  strategy: import_v411.z.literal(CrossChainIndexingStrategyIds.Omnichain),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeOmnichainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_slowestChainEqualsToOmnichainSnapshotTime).check(invariant_snapshotTimeIsTheHighestKnownBlockTimestamp);
-var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v49.z.discriminatedUnion("strategy", [
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v411.z.discriminatedUnion("strategy", [
   makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v49.z.strictObject({
-  projectedAt: makeUnixTimestampSchema(valueLabel),
-  worstCaseDistance: makeDurationSchema(valueLabel),
-  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
-}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
 
-// src/ensindexer/indexing-status/deserialize.ts
-function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
+// src/ensindexer/indexing-status/deserialize/cross-chain-indexing-status-snapshot.ts
+function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
-      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${(0, import_v410.prettifyError)(parsed.error)}
+      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
+${(0, import_v412.prettifyError)(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
-function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
+
+// src/ensindexer/indexing-status/deserialize/omnichain-indexing-status-snapshot.ts
+var import_v413 = require("zod/v4");
+function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
-      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${(0, import_v410.prettifyError)(parsed.error)}
+      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
+${(0, import_v413.prettifyError)(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
+
+// src/ensindexer/indexing-status/deserialize/realtime-indexing-status-projection.ts
+var import_v415 = require("zod/v4");
+
+// src/ensindexer/indexing-status/zod-schema/realtime-indexing-status-projection.ts
+var import_v414 = require("zod/v4");
+function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
+  const projection = ctx.value;
+  const { snapshot, projectedAt } = projection;
+  if (snapshot.snapshotTime > projectedAt) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
+    });
+  }
+}
+function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
+  const projection = ctx.value;
+  const { projectedAt, snapshot, worstCaseDistance } = projection;
+  const expectedWorstCaseDistance = projectedAt - snapshot.slowestChainIndexingCursor;
+  if (worstCaseDistance !== expectedWorstCaseDistance) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.slowestChainIndexingCursor`."
+    });
+  }
+}
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v414.z.strictObject({
+  projectedAt: makeUnixTimestampSchema(valueLabel),
+  worstCaseDistance: makeDurationSchema(valueLabel),
+  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
+}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
+
+// src/ensindexer/indexing-status/deserialize/realtime-indexing-status-projection.ts
 function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(maybeProjection);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into RealtimeIndexingStatusProjection:
-${(0, import_v410.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-var import_v411 = require("zod/v4");
-function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeSerializedChainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v411.prettifyError)(parsed.error)}
+${(0, import_v415.prettifyError)(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
 
-// src/ensindexer/indexing-status/projection.ts
+// src/ensindexer/indexing-status/realtime-indexing-status-projection.ts
 function createRealtimeIndexingStatusProjection(snapshot, now) {
   const projectedAt = Math.max(now, snapshot.snapshotTime);
   return {
@@ -1848,27 +1862,7 @@ function serializeChainIndexingSnapshots(chains) {
   return serializedSnapshots;
 }
 
-// src/ensindexer/indexing-status/serialize.ts
-function serializeCrossChainIndexingStatusSnapshotOmnichain({
-  strategy,
-  slowestChainIndexingCursor,
-  snapshotTime,
-  omnichainSnapshot
-}) {
-  return {
-    strategy,
-    slowestChainIndexingCursor,
-    snapshotTime,
-    omnichainSnapshot: serializeOmnichainIndexingStatusSnapshot(omnichainSnapshot)
-  };
-}
-function serializeRealtimeIndexingStatusProjection(indexingProjection) {
-  return {
-    projectedAt: indexingProjection.projectedAt,
-    worstCaseDistance: indexingProjection.worstCaseDistance,
-    snapshot: serializeCrossChainIndexingStatusSnapshotOmnichain(indexingProjection.snapshot)
-  };
-}
+// src/ensindexer/indexing-status/serialize/omnichain-indexing-status-snapshot.ts
 function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
   switch (indexingStatus.omnichainStatus) {
     case OmnichainIndexingStatusIds.Unstarted:
@@ -1899,14 +1893,38 @@ function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
   }
 }
 
+// src/ensindexer/indexing-status/serialize/cross-chain-indexing-status-snapshot.ts
+function serializeCrossChainIndexingStatusSnapshotOmnichain({
+  strategy,
+  slowestChainIndexingCursor,
+  snapshotTime,
+  omnichainSnapshot
+}) {
+  return {
+    strategy,
+    slowestChainIndexingCursor,
+    snapshotTime,
+    omnichainSnapshot: serializeOmnichainIndexingStatusSnapshot(omnichainSnapshot)
+  };
+}
+
+// src/ensindexer/indexing-status/serialize/realtime-indexing-status-projection.ts
+function serializeRealtimeIndexingStatusProjection(indexingProjection) {
+  return {
+    projectedAt: indexingProjection.projectedAt,
+    worstCaseDistance: indexingProjection.worstCaseDistance,
+    snapshot: serializeCrossChainIndexingStatusSnapshotOmnichain(indexingProjection.snapshot)
+  };
+}
+
 // src/ensindexer/indexing-status/validate/chain-indexing-status-snapshot.ts
-var import_v412 = require("zod/v4");
+var import_v416 = require("zod/v4");
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${(0, import_v412.prettifyError)(parsed.error)}
+${(0, import_v416.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1933,10 +1951,10 @@ function serializeConfigResponse(response) {
 }
 
 // src/api/indexing-status/deserialize.ts
-var import_v414 = require("zod/v4");
+var import_v418 = require("zod/v4");
 
 // src/api/indexing-status/zod-schemas.ts
-var import_v413 = require("zod/v4");
+var import_v417 = require("zod/v4");
 
 // src/api/indexing-status/response.ts
 var IndexingStatusResponseCodes = {
@@ -1951,14 +1969,14 @@ var IndexingStatusResponseCodes = {
 };
 
 // src/api/indexing-status/zod-schemas.ts
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v413.z.strictObject({
-  responseCode: import_v413.z.literal(IndexingStatusResponseCodes.Ok),
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(IndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v413.z.strictObject({
-  responseCode: import_v413.z.literal(IndexingStatusResponseCodes.Error)
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(IndexingStatusResponseCodes.Error)
 });
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v413.z.discriminatedUnion("responseCode", [
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v417.z.discriminatedUnion("responseCode", [
   makeIndexingStatusResponseOkSchema(valueLabel),
   makeIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -1968,7 +1986,7 @@ function deserializeIndexingStatusResponse(maybeResponse) {
   const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize IndexingStatusResponse:
-${(0, import_v414.prettifyError)(parsed.error)}
+${(0, import_v418.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1988,20 +2006,20 @@ function serializeIndexingStatusResponse(response) {
 }
 
 // src/api/name-tokens/deserialize.ts
-var import_v419 = require("zod/v4");
+var import_v423 = require("zod/v4");
 
 // src/api/name-tokens/zod-schemas.ts
 var import_viem14 = require("viem");
-var import_v418 = require("zod/v4");
+var import_v422 = require("zod/v4");
 
 // src/tokenscope/assets.ts
 var import_viem13 = require("viem");
-var import_v416 = require("zod/v4");
+var import_v420 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip3 = require("caip");
 var import_viem12 = require("viem");
-var import_v415 = require("zod/v4");
+var import_v419 = require("zod/v4");
 
 // src/shared/types.ts
 var AssetNamespaces = {
@@ -2124,10 +2142,10 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // src/tokenscope/zod-schemas.ts
-var tokenIdSchemaSerializable = import_v415.z.string();
-var tokenIdSchemaNative = import_v415.z.preprocess(
+var tokenIdSchemaSerializable = import_v419.z.string();
+var tokenIdSchemaNative = import_v419.z.preprocess(
   (v) => typeof v === "string" ? BigInt(v) : v,
-  import_v415.z.bigint().positive()
+  import_v419.z.bigint().positive()
 );
 function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
   if (serializable) {
@@ -2137,13 +2155,13 @@ function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false
   }
 }
 var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
-  return import_v415.z.object({
-    assetNamespace: import_v415.z.enum(AssetNamespaces),
+  return import_v419.z.object({
+    assetNamespace: import_v419.z.enum(AssetNamespaces),
     contract: makeAccountIdSchema(valueLabel),
     tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
   });
 };
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v415.z.preprocess((v) => {
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v419.z.preprocess((v) => {
   if (typeof v === "string") {
     const result = new import_caip3.AssetId(v);
     return {
@@ -2167,20 +2185,20 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v415.z.object({
-  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.NameWrapper),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v415.z.object({
-  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.FullyOnchain),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v415.z.object({
-  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v415.z.object({
-  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
@@ -2193,16 +2211,16 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v415.z.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v419.z.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v415.z.object({
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v419.z.object({
   token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v415.z.enum(NFTMintStatuses)
+  mintStatus: import_v419.z.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
@@ -2218,7 +2236,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${(0, import_v416.prettifyError)(parsed.error)}
+${(0, import_v420.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2228,7 +2246,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${(0, import_v416.prettifyError)(parsed.error)}
+${(0, import_v420.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2450,10 +2468,10 @@ ${formatNFTTransferEventMetadata(metadata)}`
 };
 
 // src/api/shared/errors/zod-schemas.ts
-var import_v417 = require("zod/v4");
-var ErrorResponseSchema = import_v417.z.object({
-  message: import_v417.z.string(),
-  details: import_v417.z.optional(import_v417.z.unknown())
+var import_v421 = require("zod/v4");
+var ErrorResponseSchema = import_v421.z.object({
+  message: import_v421.z.string(),
+  details: import_v421.z.optional(import_v421.z.unknown())
 });
 
 // src/api/name-tokens/response.ts
@@ -2492,10 +2510,10 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v418.z.object({
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v422.z.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v418.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: import_v422.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
@@ -2537,32 +2555,32 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v418.z.strictObject({
-  responseCode: import_v418.z.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v418.z.strictObject({
-  responseCode: import_v418.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v418.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v418.z.strictObject({
-  responseCode: import_v418.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v418.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v418.z.strictObject({
-  responseCode: import_v418.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v418.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v418.z.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v422.z.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return import_v418.z.discriminatedUnion("responseCode", [
+  return import_v422.z.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
@@ -2575,7 +2593,7 @@ function deserializedNameTokensResponse(maybeResponse) {
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${(0, import_v419.prettifyError)(parsed.error)}
+${(0, import_v423.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2649,14 +2667,14 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/api/registrar-actions/deserialize.ts
-var import_v423 = require("zod/v4");
+var import_v427 = require("zod/v4");
 
 // src/api/registrar-actions/zod-schemas.ts
 var import_ens7 = require("viem/ens");
-var import_v422 = require("zod/v4");
+var import_v426 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
-var import_v420 = require("zod/v4");
+var import_v424 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
 var import_viem15 = require("viem");
@@ -2731,11 +2749,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v420.z.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v424.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v420.z.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v424.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2751,18 +2769,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v420.z.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v424.z.union([
   // pricing available
-  import_v420.z.object({
+  import_v424.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v420.z.object({
-    baseCost: import_v420.z.null(),
-    premium: import_v420.z.null(),
-    total: import_v420.z.null()
+  import_v424.z.object({
+    baseCost: import_v424.z.null(),
+    premium: import_v424.z.null(),
+    total: import_v424.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2785,9 +2803,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v420.z.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v424.z.union([
   // referral available
-  import_v420.z.object({
+  import_v424.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2795,9 +2813,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v420.z.object({
-    encodedReferrer: import_v420.z.null(),
-    decodedReferrer: import_v420.z.null()
+  import_v424.z.object({
+    encodedReferrer: import_v424.z.null(),
+    decodedReferrer: import_v424.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2810,9 +2828,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v420.z.string().nonempty();
-var EventIdsSchema = import_v420.z.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v420.z.object({
+var EventIdSchema = import_v424.z.string().nonempty();
+var EventIdsSchema = import_v424.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v424.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -2826,38 +2844,38 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => im
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v420.z.literal(RegistrarActionTypes.Registration)
+  type: import_v424.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v420.z.literal(RegistrarActionTypes.Renewal)
+  type: import_v424.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v420.z.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v424.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/api/shared/pagination/zod-schemas.ts
-var import_v421 = require("zod/v4");
+var import_v425 = require("zod/v4");
 
 // src/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
 // src/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v421.z.object({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v425.z.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v421.z.object({
-  totalRecords: import_v421.z.literal(0),
-  totalPages: import_v421.z.literal(1),
-  hasNext: import_v421.z.literal(false),
-  hasPrev: import_v421.z.literal(false),
-  startIndex: import_v421.z.undefined(),
-  endIndex: import_v421.z.undefined()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v425.z.object({
+  totalRecords: import_v425.z.literal(0),
+  totalPages: import_v425.z.literal(1),
+  hasNext: import_v425.z.literal(false),
+  hasPrev: import_v425.z.literal(false),
+  startIndex: import_v425.z.undefined(),
+  endIndex: import_v425.z.undefined()
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -2892,15 +2910,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v421.z.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v425.z.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v421.z.boolean(),
-  hasPrev: import_v421.z.boolean(),
+  hasNext: import_v425.z.boolean(),
+  hasPrev: import_v425.z.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v421.z.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v425.z.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -2930,21 +2948,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v422.z.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v426.z.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v422.z.object({
-  responseCode: import_v422.z.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v422.z.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v426.z.object({
+  responseCode: import_v426.z.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v426.z.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`).optional()
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v422.z.strictObject({
-  responseCode: import_v422.z.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v426.z.strictObject({
+  responseCode: import_v426.z.literal(RegistrarActionsResponseCodes.Error),
   error: ErrorResponseSchema
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v422.z.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v426.z.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -2955,7 +2973,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v423.prettifyError)(parsed.error)}
+${(0, import_v427.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3203,12 +3221,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/api/shared/errors/deserialize.ts
-var import_v424 = require("zod/v4");
+var import_v428 = require("zod/v4");
 function deserializeErrorResponse(maybeErrorResponse) {
   const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v424.prettifyError)(parsed.error)}
+${(0, import_v428.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;