musora-content-services 2.185.0 → 2.186.0

package/.agent/decisions/2026-10-01-agi-remove-limit-from-queries.md

@@ -0,0 +1,60 @@
+---
+date: 2026-10-01
+branch: chore/AGI-remove-limit-from-queries
+pr: https://github.com/railroadmedia/musora-content-services/pull/1067
+status: open
+tags: [[chore]]
+related: [[2026-07-20-query-builder-tostring]]
+---
+
+# Optional limit in fetchArtists, fetchGenres and fetchInstructors
+
+## Context
+`fetchArtists`, `fetchGenres` and `fetchInstructors` destructured their options with a hard-coded `limit = 20`. Callers that wanted the complete list of artists, genres or instructors had no way to express that — the only workaround was to pass an arbitrarily large number. The requirement was to make `limit` genuinely optional, with omission meaning "return everything".
+
+## Decision
+Removed the `limit = 20` default from all three services and made the `.slice()` call conditional:
+
+```ts
+const { sort = 'lower(name)', offset = 0, limit } = options
+
+const data = query()
+  .and(type)
+  .order(getSortOrder(sort, brand))
+  .select(...)
+  .postFilter(postFilter)
+
+if (limit) data.slice(offset, limit)
+```
+
+Simply dropping the default was not sufficient and would have shipped a silent breaking change. `QueryBuilder.slice(offset, limit)` in `src/lib/sanity/query.ts` computes its expression as:
+
+```ts
+const sliceExpr = !limit ? `[${offset}]` : `[${offset}...${offset + limit}]`
+```
+
+A missing `limit` therefore produces `[offset]` — a single-index GROQ slice, the same branch `first()` depends on — not an unbounded one. The response shape would have flipped from `{ data: Artist[] }` to `{ data: Artist }`, and TypeScript would not have caught it because the declared return type stays `Artists`.
+
+Skipping the `.slice()` call instead leaves `state.slice` at its monoid identity (`''`), so `build()` emits no slice expression and GROQ returns the full array.
+
+The guard is placed after the builder chain rather than inside it. This is safe for two reasons, both already covered by `test/unit/lib/query.test.ts`: every builder method returns the same closure instance and mutates shared state (`returns same builder instance for chaining`, `builds valid query after multiple modifications`), and `build()` renders state in a fixed order regardless of call order, so the slice still lands last in the emitted query.
+
+## Alternatives Considered
+**Fixing `slice()` itself** to treat a nullish `limit` as "no slice" is the more correct fix — `!limit` is the wrong test, since `limit: 0` also falls through to the single-index branch. Rejected for now because `first()` is implemented as `this.slice()` and relies on that exact branch, making it a wider change than this ticket warranted.
+
+**Honouring `offset` without a `limit`** via a sentinel ceiling (`data.slice(offset, MAX_RESULTS)`). Rejected: GROQ has no open-ended slice syntax (`[5...]` is invalid), so any such value would be arbitrary, and no current caller paginates without a limit.
+
+**Adding a `when(condition, apply)` combinator** to `QueryBuilder` to keep the chain fluent. Rejected as new public API for a single call site. An audit of the other conditional clauses in these queries showed none would adopt it: `searchMatch`, `includedFields` and `progressIds` already return `Filters.empty` when their input is absent, and the `and`/`or` monoids drop empty strings, so conditionality is handled at the filter layer rather than the builder layer.
+
+## Process Notes
+The `f.brand(brand)` helper is the one filter that does not self-nullify, which is why four sites spell out `brand ? f.brand(brand) : f.empty` (`counts.ts:26`, `:33`, `:58` and `filter.ts:481`). Making it return `Filters.empty` on a falsy brand would remove those ternaries and match the surrounding idiom, but it was deliberately left alone: an absent brand filter does not return nothing, it returns every brand's content. The required `brand: string` signature currently blocks that mistake at compile time, and the explicit ternary keeps "all brands" a conscious decision at the call site.
+
+The post-chain guard only works because builders are interpolated lazily. `data` is a `QueryBuilder`, not a string; the `q` template literal coerces it via the `toString()` added in [[2026-07-20-query-builder-tostring]], which runs below the guard. Had `build()` been called eagerly at the end of the chain, the conditional slice would have been dropped.
+
+## Consequences
+- Omitting `limit` now returns the complete list instead of the first 20 rows.
+- `limit: 0` previously produced a single-object response through the faulty `!limit` branch; it now returns the full list.
+- An `offset` passed without a `limit` is ignored rather than approximated.
+- No caller changes required. Both existing consumers pass an explicit limit: `MusoraApp/src_v2/components/screens/CollectionList.tsx` uses `limit: 50`, and `musora-platform-frontend/src/modules/agi/services/entity.service.ts` defaults `fetchAll` to 40.
+- Unbounded queries are now expressible against Sanity, so a caller omitting `limit` on a large brand will fetch every matching document. Worth watching if a new consumer adopts it on a hot path.
+- Left unaddressed: the `Artists`, `Genres` and `Instructors` interfaces declare `total: number`, but the query only projects `"data"`. `total` is always `undefined`, so the pagination meta in `entity.service.ts` never populates.

package/.claude/settings.local.json

@@ -1,14 +1,4 @@
 {
-  "permissions": {
-    "allow": [
-      "Bash(rg:*)",
-      "Bash(npm run lint:*)",
-      "Bash(ls:*)",
-      "Bash(npm test *)",
-      "Bash(npx jest *)"
-    ],
-    "deny": []
-  },
   "enabledMcpjsonServers": [
     "1password",
     "atlassian",
@@ -19,17 +9,22 @@
     "hex",
     "sanity",
     "mysql",
+    "mysql-staging",
+    "mysql-local",
     "slack",
     "langfuse",
     "chrome-devtools",
+    "mobile",
     "railway",
     "github",
     "asana",
     "nightwatch",
-    "mysql-staging",
-    "mysql-local",
-    "mobile",
     "sentry",
-    "customerio"
+    "customerio",
+    "vercel",
+    "cloudflare"
+  ],
+  "disabledMcpjsonServers": [
+    "mysql-archive"
   ]
 }

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.186.0](https://github.com/railroadmedia/musora-content-services/compare/v2.185.1...v2.186.0) (2026-10-16)
+
+
+### Features
+
+* **MU2-1384:** Port recommendations to the new sanity builders ([#1058](https://github.com/railroadmedia/musora-content-services/issues/1058)) ([0e2e41f](https://github.com/railroadmedia/musora-content-services/commit/0e2e41f86e26e16af18b894ab2472d54e3008022))
+* **MU2-2025:** Add promotional campaign queries and claim state ([#1081](https://github.com/railroadmedia/musora-content-services/issues/1081)) ([921ab1e](https://github.com/railroadmedia/musora-content-services/commit/921ab1effee488253413fd42146377e986571e45))
+
+### [2.185.1](https://github.com/railroadmedia/musora-content-services/compare/v2.185.0...v2.185.1) (2026-10-06)
+
 ## [2.185.0](https://github.com/railroadmedia/musora-content-services/compare/v2.184.1...v2.185.0) (2026-10-01)
 
 

package/jest.config.js

@@ -28,7 +28,6 @@ export default {
     'src/**/*.{js,ts}',
     '!src/services/sanity.js',
     '!src/services/railcontent.js',
-    '!src/services/recommendations.js',
     '!src/index.js',
     '!src/index.d.ts',
     '!src/services/user/account.ts',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "2.185.0",
+  "version": "2.186.0",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",

package/src/index.d.ts

@@ -81,7 +81,6 @@ import {
 	getNewAndUpcoming,
 	getOwnedContent,
 	getRecent,
-	getRecommendedForYou,
 	getScheduleContentRows,
 	getTabResults
 } from './services/content.js';
@@ -217,6 +216,14 @@ import {
 	fetchMarketingTestimonials
 } from './services/marketing/marketing.ts';
 
+import {
+	claimPromotionalCampaign,
+	dismissPromotionalCampaign,
+	fetchAvailablePromotionalCampaigns,
+	fetchPromotionalCampaigns,
+	fetchUserCampaignStates
+} from './services/marketing/promotions.ts';
+
 import {
 	acceptInvite,
 	createAccount,
@@ -351,10 +358,11 @@ import {
 
 import {
 	fetchSimilarItems,
+	getRecommendedForYou,
 	rankCategories,
 	rankItems,
 	recommendations
-} from './services/recommendations.js';
+} from './services/recommendations.ts';
 
 import {
 	getReportIssueOptions,
@@ -434,6 +442,7 @@ import {
 	confirmEmailChange,
 	createPendingAccount,
 	deleteAccount,
+	maskEmail,
 	numberOfActiveUsers,
 	requestEmailChange,
 	resetPassword,
@@ -584,6 +593,7 @@ declare module 'musora-content-services' {
 		buildEntityAndTotalQuery,
 		buildImageSRC,
 		calculateLongestStreaks,
+		claimPromotionalCampaign,
 		clearAllCachedData,
 		clearState,
 		closeComment,
@@ -624,6 +634,7 @@ declare module 'musora-content-services' {
 		deleteProfilePicture,
 		deleteThread,
 		deleteUserActivity,
+		dismissPromotionalCampaign,
 		doesUserHaveMembership,
 		duplicatePlaylist,
 		editComment,
@@ -637,6 +648,7 @@ declare module 'musora-content-services' {
 		fetchArtistBySlug,
 		fetchArtistLessons,
 		fetchArtists,
+		fetchAvailablePromotionalCampaigns,
 		fetchBrandsByContentIds,
 		fetchByRailContentId,
 		fetchByRailContentIds,
@@ -703,6 +715,7 @@ declare module 'musora-content-services' {
 		fetchPost,
 		fetchPosts,
 		fetchPracticeGoals,
+		fetchPromotionalCampaigns,
 		fetchPublicAnnouncement,
 		fetchQuizAnswers,
 		fetchRecent,
@@ -731,6 +744,7 @@ declare module 'musora-content-services' {
 		fetchUninterests,
 		fetchUnreadCount,
 		fetchUpcomingEvents,
+		fetchUserCampaignStates,
 		fetchUserPermissions,
 		fetchUserPlaylists,
 		fetchUserPracticeMeta,
@@ -851,6 +865,7 @@ declare module 'musora-content-services' {
 		markNotificationAsRead,
 		markNotificationAsUnread,
 		markThreadAsRead,
+		maskEmail,
 		numberOfActiveUsers,
 		onProgressSaved,
 		openComment,

package/src/index.js

@@ -85,7 +85,6 @@ import {
 	getNewAndUpcoming,
 	getOwnedContent,
 	getRecent,
-	getRecommendedForYou,
 	getScheduleContentRows,
 	getTabResults
 } from './services/content.js';
@@ -221,6 +220,14 @@ import {
 	fetchMarketingTestimonials
 } from './services/marketing/marketing.ts';
 
+import {
+	claimPromotionalCampaign,
+	dismissPromotionalCampaign,
+	fetchAvailablePromotionalCampaigns,
+	fetchPromotionalCampaigns,
+	fetchUserCampaignStates
+} from './services/marketing/promotions.ts';
+
 import {
 	acceptInvite,
 	createAccount,
@@ -355,10 +362,11 @@ import {
 
 import {
 	fetchSimilarItems,
+	getRecommendedForYou,
 	rankCategories,
 	rankItems,
 	recommendations
-} from './services/recommendations.js';
+} from './services/recommendations.ts';
 
 import {
 	getReportIssueOptions,
@@ -438,6 +446,7 @@ import {
 	confirmEmailChange,
 	createPendingAccount,
 	deleteAccount,
+	maskEmail,
 	numberOfActiveUsers,
 	requestEmailChange,
 	resetPassword,
@@ -583,6 +592,7 @@ export {
 	buildEntityAndTotalQuery,
 	buildImageSRC,
 	calculateLongestStreaks,
+	claimPromotionalCampaign,
 	clearAllCachedData,
 	clearState,
 	closeComment,
@@ -623,6 +633,7 @@ export {
 	deleteProfilePicture,
 	deleteThread,
 	deleteUserActivity,
+	dismissPromotionalCampaign,
 	doesUserHaveMembership,
 	duplicatePlaylist,
 	editComment,
@@ -636,6 +647,7 @@ export {
 	fetchArtistBySlug,
 	fetchArtistLessons,
 	fetchArtists,
+	fetchAvailablePromotionalCampaigns,
 	fetchBrandsByContentIds,
 	fetchByRailContentId,
 	fetchByRailContentIds,
@@ -702,6 +714,7 @@ export {
 	fetchPost,
 	fetchPosts,
 	fetchPracticeGoals,
+	fetchPromotionalCampaigns,
 	fetchPublicAnnouncement,
 	fetchQuizAnswers,
 	fetchRecent,
@@ -730,6 +743,7 @@ export {
 	fetchUninterests,
 	fetchUnreadCount,
 	fetchUpcomingEvents,
+	fetchUserCampaignStates,
 	fetchUserPermissions,
 	fetchUserPlaylists,
 	fetchUserPracticeMeta,
@@ -850,6 +864,7 @@ export {
 	markNotificationAsRead,
 	markNotificationAsUnread,
 	markThreadAsRead,
+	maskEmail,
 	numberOfActiveUsers,
 	onProgressSaved,
 	openComment,

package/src/lib/ads/async-either.ts

@@ -0,0 +1,148 @@
+import { Either } from './either'
+
+const toError = (error: unknown, message?: string): Error =>
+  error instanceof Error
+    ? error
+    : new Error(message ?? String(error ?? 'AsyncEither.attempt failed'))
+
+/**
+ * An {@link Either} that has not resolved yet, so a chain can keep going across asynchronous
+ * steps instead of dropping back into `.then()` at every one. Not a `TaskEither`: the work is
+ * already running when the AsyncEither is built.
+ * @example
+ * const lessons = await AsyncEither.of(run<Lesson[]>(groq))
+ *   .map((lessons) => lessons ?? [])
+ *   .mapAsync((lessons) => decorateNavigateTo(lessons))
+ *   .ltap((error) => console.error(error.message))
+ *   .recover([])
+ */
+export class AsyncEither<L, R> implements PromiseLike<Either<L, R>> {
+  private constructor(private readonly promise: Promise<Either<L, R>>) {}
+
+  /** @param promise - the pending Either to lift */
+  static of<L, R>(promise: Promise<Either<L, R>>): AsyncEither<L, R> {
+    return new AsyncEither(promise)
+  }
+
+  static attempt<R>(fn: () => Promise<R>, message?: string): AsyncEither<Error, R>
+  static attempt<R, L>(
+    fn: () => Promise<R>,
+    onError: (error: unknown) => L
+  ): AsyncEither<L, R>
+  /**
+   * @param fn - the work to run; a rejection becomes a Left instead of propagating
+   * @param onError - a message used when `fn` rejects with a non-Error, or a function receiving
+   * the rejection untouched when the left has to carry more than a message
+   * @example
+   * AsyncEither.attempt(() => fetchStates(slugs), 'failed to fetch campaign state')
+   * @example
+   * AsyncEither.attempt(
+   *   () => client.query(groq),
+   *   (error) => new SanityQueryError('Sanity query failed', groq, error)
+   * )
+   */
+  static attempt<R, L>(
+    fn: () => Promise<R>,
+    onError?: string | ((error: unknown) => L)
+  ): AsyncEither<L | Error, R> {
+    const message = typeof onError === 'string' ? onError : undefined
+    const toLeft =
+      typeof onError === 'function' ? onError : (error: unknown) => toError(error, message)
+
+    return AsyncEither.of(
+      fn().then(
+        (value) => Either.right<L | Error, R>(value),
+        (error) => Either.left<L | Error, R>(toLeft(error))
+      )
+    )
+  }
+
+  /** @param fn - maps the right value once it resolves */
+  map<T>(fn: (r: R) => T): AsyncEither<L, T> {
+    return AsyncEither.of(this.promise.then((either) => either.map(fn)))
+  }
+
+  /** @param fn - maps the right value with an asynchronous function; a rejection propagates */
+  mapAsync<T>(fn: (r: R) => Promise<T>): AsyncEither<L, T> {
+    return AsyncEither.of(this.promise.then((either) => either.mapAsync(fn)))
+  }
+
+  /**
+   * @param fn - maps the right value to another AsyncEither, flattening the result; its left type
+   * may differ, in which case the result carries the union of both
+   */
+  flatMap<T, E = L>(fn: (r: R) => AsyncEither<E, T>): AsyncEither<L | E, T> {
+    return AsyncEither.of(
+      this.promise.then((either) =>
+        either.fold(
+          (l) => Promise.resolve(Either.left<L | E, T>(l)),
+          (r) => fn(r).promise as Promise<Either<L | E, T>>
+        )
+      )
+    )
+  }
+
+  /** @param fn - maps the left value once it resolves */
+  lmap<T>(fn: (l: L) => T): AsyncEither<T, R> {
+    return AsyncEither.of(this.promise.then((either) => either.lmap(fn)))
+  }
+
+  /** @param fn - maps the left value to another AsyncEither, flattening the result */
+  lflatMap<T>(fn: (l: L) => AsyncEither<T, R>): AsyncEither<T, R> {
+    return AsyncEither.of(
+      this.promise.then((either) =>
+        either.fold(
+          (l) => fn(l).promise,
+          (r) => Promise.resolve(Either.right<T, R>(r))
+        )
+      )
+    )
+  }
+
+  /** @param fn - visits the right value without modifying it */
+  tap(fn: (r: R) => void): AsyncEither<L, R> {
+    return AsyncEither.of(this.promise.then((either) => either.tap(fn)))
+  }
+
+  /** @param fn - visits the left value without modifying it */
+  ltap(fn: (l: L) => void): AsyncEither<L, R> {
+    return AsyncEither.of(this.promise.then((either) => either.ltap(fn)))
+  }
+
+  /**
+   * @param onLeft - handles the left value
+   * @param onRight - handles the right value
+   * @returns {Promise<T | U>}
+   */
+  fold<T, U>(onLeft: (l: L) => T, onRight: (r: R) => U): Promise<T | U> {
+    return this.promise.then((either) => either.fold(onLeft, onRight))
+  }
+
+  /**
+   * @param defaultValue - returned when the resolved Either is a Left
+   * @returns {Promise<R>}
+   */
+  recover(defaultValue: R): Promise<R> {
+    return this.promise.then((either) => either.recover(defaultValue))
+  }
+
+  /**
+   * @param error - thrown instead of the left, or used as the message of the thrown Error
+   * @returns {Promise<R>}
+   */
+  orFail(error?: string | Error): Promise<R> {
+    return this.promise.then((either) => either.orFail(error))
+  }
+
+  /** @returns {Promise<Either<L, R>>} */
+  unlift(): Promise<Either<L, R>> {
+    return this.promise
+  }
+
+  then<T = Either<L, R>, U = never>(
+    onfulfilled?: ((either: Either<L, R>) => T | PromiseLike<T>) | null,
+    onrejected?: ((reason: unknown) => U | PromiseLike<U>) | null
+  ): Promise<T | U> {
+    return this.promise.then(onfulfilled, onrejected)
+  }
+}

package/src/lib/ads/coproduct.ts

@@ -84,6 +84,42 @@ export abstract class Coproduct<L, R>
    */
   abstract fold<T, U>(onLeft: (l: L) => T, onRight: (r: R) => U): T | U
 
+  /**
+   * Unwraps the right value, throwing the left instead of returning it. Use at the edge of a
+   * chain where a failure has to become an exception.
+   * @param error - thrown instead of the left, or used as the message of the thrown Error
+   * @throws the left value when it is an `Error`, otherwise an `Error` wrapping it
+   * @example
+   * Coproduct.right(5).orFail()                          // 5
+   * Coproduct.left(new Error('bad')).orFail()            // throws Error('bad')
+   * Coproduct.left('bad').orFail('error during request') // throws Error('error during request')
+   * Coproduct.left('bad').orFail(new HttpError(502))     // throws HttpError(502)
+   */
+  orFail(error?: string | Error): R {
+    return this.fold(
+      (l) => {
+        throw Coproduct.toError(l, error)
+      },
+      (r) => r
+    )
+  }
+
+  private static toError<L>(value: L, error?: string | Error): Error {
+    if (error instanceof Error) {
+      return error
+    }
+
+    if (typeof error === 'string') {
+      return new Error(error)
+    }
+
+    if (value instanceof Error) {
+      return value
+    }
+
+    return new Error(typeof value === 'string' ? value : 'Coproduct.orFail called on a Left')
+  }
+
   /** Convenience {@link fold} that applies the same `fn` regardless of side. */
   foldMap<T>(initial: T, fn: (acc: T, value: L | R) => T): T {
     return this.fold(

package/src/lib/sanity/decorators/navigate-to.ts

@@ -4,7 +4,7 @@ import {
   CollectionParameter,
   STATE,
 } from '../../../services/sync/models/ContentProgress'
-import { Progress } from '@/services/progress'
+import { Progress } from '../../../services/progress'
 
 export const NAVIGATE_TO_FIELD = 'navigateTo' as const
 
@@ -15,9 +15,10 @@ const NAVIGABLE_TYPES = [
   'song-tutorial',
   COLLECTION_TYPE.LEARNING_PATH,
   'skill-pack',
+  'documentary',
 ] as const
 
-const COURSE_FLOW_TYPES = ['course', 'skill-pack', 'song-tutorial']
+const COURSE_FLOW_TYPES = ['course', 'skill-pack', 'song-tutorial', 'documentary']
 const GUIDED_FLOW_TYPES = ['guided-course', COLLECTION_TYPE.LEARNING_PATH]
 const TWO_DEPTH_TYPES = ['course-collection']
 
@@ -46,11 +47,18 @@ export type WithNavigateTo<T extends NavigateToDecoratable> = T & {
   navigateTo: NavigateTo | null
 }
 
+const definedChildrenOf = (content: NavigateToDecoratable): NavigateToDecoratable[] =>
+  (content.children ?? []).filter(Boolean)
+
 function buildNavigateTo(
-  content: NavigateToDecoratable,
+  content: NavigateToDecoratable | null | undefined,
   child: NavigateTo | null = null,
   collection: NavigateTo['collection'] = null
-): NavigateTo {
+): NavigateTo | null {
+  if (!content) {
+    return null
+  }
+
   return {
     id: content.id,
     type: content.type,
@@ -72,10 +80,10 @@ async function prefetchStates(items: NavigateToDecoratable[]): Promise<NavigateC
   for (const item of items) {
     if (!item || !NAVIGABLE_TYPES.includes(item.type as (typeof NAVIGABLE_TYPES)[number])) continue
     ids.add(item.id)
-    for (const child of item.children ?? []) {
+    for (const child of definedChildrenOf(item)) {
       ids.add(child.id)
       if (TWO_DEPTH_TYPES.includes(item.type)) {
-        for (const grandchild of child.children ?? []) {
+        for (const grandchild of definedChildrenOf(child)) {
           ids.add(grandchild.id)
         }
       }
@@ -92,8 +100,8 @@ async function computeNavigateTo(
 ): Promise<NavigateTo | null> {
   if (!NAVIGABLE_TYPES.includes(content.type as (typeof NAVIGABLE_TYPES)[number])) return null
 
-  const children = content.children
-  if (!children || children.length === 0) return null
+  const children = definedChildrenOf(content)
+  if (children.length === 0) return null
 
   const contentState = ctx?.states.get(content.id) ?? (await Progress.state(content.id))
   if (contentState !== STATE.STARTED) {
@@ -117,14 +125,12 @@ async function computeNavigateTo(
       lastInteractedStatus === STATE.STARTED
         ? lastInteractedId
         : Progress.incompleteLesson(childrenStates, content.type, lastInteractedId)
-    const target = childrenById.get(targetId)
-    return target ? buildNavigateTo(target) : null
+    return buildNavigateTo(childrenById.get(targetId))
   }
 
   if (GUIDED_FLOW_TYPES.includes(content.type)) {
     const targetId = Progress.incompleteLesson(childrenStates, content.type, lastInteractedId)
-    const target = childrenById.get(targetId)
-    return target ? buildNavigateTo(target) : null
+    return buildNavigateTo(childrenById.get(targetId))
   }
 
   if (TWO_DEPTH_TYPES.includes(content.type)) {
@@ -147,10 +153,10 @@ export function navigateToDecorator(
   }
 }
 
-export function decorateNavigateTo<T extends NavigateToDecoratable>(
+export async function decorateNavigateTo<T extends NavigateToDecoratable>(
   items: T[]
 ): Promise<WithNavigateTo<T>[]>
-export function decorateNavigateTo<T extends NavigateToDecoratable>(
+export async function decorateNavigateTo<T extends NavigateToDecoratable>(
   items: T
 ): Promise<WithNavigateTo<T>>
 export async function decorateNavigateTo<T extends NavigateToDecoratable>(