@eightyfourthousand/client-graphql 2026.3.1 → 2026.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eightyfourthousand/client-graphql",
-  "version": "2026.3.1",
+  "version": "2026.4.0",
   "description": "GraphQL client helpers and typed query functions for 84000 applications.",
   "private": false,
   "repository": {

package/src/index.ts

@@ -8,8 +8,6 @@ export {
 // Functions
 export {
   getPassage,
-  getTranslationPassages,
-  getTranslationPassagesAround,
   getTranslationBlocks,
   getTranslationBlocksAround,
   getTranslationTitles,
@@ -19,10 +17,7 @@ export {
   getTranslationUuids,
   getTranslationToc,
   getTranslationImprint,
-  getGlossaryTerms,
-  getGlossaryEntry,
   getGlossaryInstance,
-  getWorkGlossary,
   getWorkGlossaryTerms,
   getWorkGlossaryTermsAround,
   type GlossaryTermsPage,
@@ -31,12 +26,13 @@ export {
   getBibliographyEntry,
   getWorkBibliography,
   getWorkFolios,
-  getWorks,
   hasPermission,
+  replace,
   savePassages,
   type TranslationBlocksPage,
-  type WorksPage,
   type Permission,
+  type ReplaceType,
+  type ReplacedPassage,
 } from './lib/functions';
 
 // Re-export types from @eightyfourthousand/data-access for convenience

package/src/lib/functions/get-glossary-instance.ts

@@ -15,6 +15,7 @@ const GET_GLOSSARY_INSTANCE = gql`
         pali
         chinese
         wylie
+        alternatives
       }
     }
   }

package/src/lib/functions/get-passage.ts

@@ -40,8 +40,8 @@ const GET_PASSAGE = gql`
     }
   }
 
-  query GetPassage($uuid: ID!) {
-    passage(uuid: $uuid) {
+  query GetPassage($uuid: ID, $xmlId: String) {
+    passage(uuid: $uuid, xmlId: $xmlId) {
       ...PassageWithAnnotations
     }
   }
@@ -52,18 +52,21 @@ type GetPassageResponse = {
 };
 
 /**
- * Get a single passage by UUID.
+ * Get a single passage by UUID or XML ID.
  */
 export async function getPassage({
   client,
   uuid,
+  xmlId,
 }: {
   client: GraphQLClient;
-  uuid: string;
+  uuid?: string;
+  xmlId?: string;
 }): Promise<Passage | undefined> {
   try {
     const response = await client.request<GetPassageResponse>(GET_PASSAGE, {
       uuid,
+      xmlId,
     });
 
     if (!response.passage) {

package/src/lib/functions/get-translation-blocks-around.ts

@@ -70,9 +70,7 @@ type GetPassagesAroundWithJsonResponse = {
 /**
  * Get translation blocks (TipTap JSON) around a specific passage UUID.
  *
- * Unlike getTranslationPassagesAround which returns Passage objects,
- * this function returns pre-transformed TipTap editor blocks
- * ready for rendering.
+ * Returns pre-transformed TipTap editor blocks ready for rendering.
  */
 export async function getTranslationBlocksAround({
   client,

package/src/lib/functions/get-translation-blocks.ts

@@ -96,9 +96,7 @@ function mapDirection(
 /**
  * Get paginated translation blocks (TipTap JSON) for a work.
  *
- * Unlike getTranslationPassages which returns Passage objects,
- * this function returns pre-transformed TipTap editor blocks
- * ready for rendering.
+ * Returns pre-transformed TipTap editor blocks ready for rendering.
  */
 export async function getTranslationBlocks({
   client,

package/src/lib/functions/get-work-glossary-terms-around.ts

@@ -29,6 +29,7 @@ const GET_WORK_GLOSSARY_TERMS_AROUND = gql`
             pali
             chinese
             wylie
+            alternatives
           }
           passages(first: 10) {
             items {

package/src/lib/functions/get-work-glossary-terms.ts

@@ -1,6 +1,9 @@
 import type { GraphQLClient } from 'graphql-request';
 import { gql } from 'graphql-request';
-import type { GlossaryTermInstance, PaginationDirection } from '@eightyfourthousand/data-access';
+import type {
+  GlossaryTermInstance,
+  PaginationDirection,
+} from '@eightyfourthousand/data-access';
 
 const GET_WORK_GLOSSARY_TERMS = gql`
   query GetWorkGlossaryTerms(
@@ -29,6 +32,7 @@ const GET_WORK_GLOSSARY_TERMS = gql`
             pali
             chinese
             wylie
+            alternatives
           }
           passages(first: 10) {
             items {

package/src/lib/functions/index.ts

@@ -1,6 +1,4 @@
 export { getPassage } from './get-passage';
-export { getTranslationPassages } from './get-translation-passages';
-export { getTranslationPassagesAround } from './get-translation-passages-around';
 export {
   getTranslationBlocks,
   type TranslationBlocksPage,
@@ -15,10 +13,7 @@ export { getTranslationsMetadata } from './get-translations-metadata';
 export { getTranslationUuids } from './get-translation-uuids';
 export { getTranslationToc } from './get-translation-toc';
 export { getTranslationImprint } from './get-translation-imprint';
-export { getGlossaryTerms } from './get-glossary-terms';
-export { getGlossaryEntry } from './get-glossary-entry';
 export { getGlossaryInstance } from './get-glossary-instance';
-export { getWorkGlossary } from './get-work-glossary';
 export {
   getWorkGlossaryTerms,
   type GlossaryTermsPage,
@@ -28,6 +23,6 @@ export { getTermPassages, type GlossaryPassagesPage } from './get-term-passages'
 export { getBibliographyEntry } from './get-bibliography-entry';
 export { getWorkBibliography } from './get-work-bibliography';
 export { getWorkFolios } from './get-work-folios';
-export { getWorks, type WorksPage } from './get-works';
 export { hasPermission, type Permission } from './has-permission';
+export { replace, type ReplaceType, type ReplacedPassage } from './replace';
 export { savePassages } from './save-passages';

package/src/lib/functions/replace.ts

@@ -0,0 +1,91 @@
+import type { GraphQLClient } from 'graphql-request';
+import { gql } from 'graphql-request';
+import type { TranslationEditorContentItem } from '@eightyfourthousand/data-access';
+
+export type ReplaceType = 'PASSAGE';
+
+export interface ReplacedPassage {
+  json?: TranslationEditorContentItem | null;
+  uuid: string;
+}
+
+interface ReplaceResponse {
+  replace: {
+    deletedAnnotationCount: number;
+    error?: string;
+    nextOccurrenceStart?: number | null;
+    nextPassageUuid?: string | null;
+    passages: ReplacedPassage[];
+    replacedOccurrenceCount: number;
+    success: boolean;
+    updatedAnnotationCount: number;
+    updatedCount: number;
+  };
+}
+
+const REPLACE_MUTATION = gql`
+  mutation Replace(
+    $searchText: String!
+    $replaceText: String!
+    $targetUuids: [ID!]!
+    $type: ReplaceType
+    $occurrenceIndex: Int
+    $cursorPassageUuid: ID
+    $cursorStart: Int
+  ) {
+    replace(
+      searchText: $searchText
+      replaceText: $replaceText
+      targetUuids: $targetUuids
+      type: $type
+      occurrenceIndex: $occurrenceIndex
+      cursorPassageUuid: $cursorPassageUuid
+      cursorStart: $cursorStart
+    ) {
+      success
+      updatedCount
+      replacedOccurrenceCount
+      updatedAnnotationCount
+      deletedAnnotationCount
+      nextPassageUuid
+      nextOccurrenceStart
+      error
+      passages {
+        uuid
+        json
+      }
+    }
+  }
+`;
+
+export const replace = async ({
+  client,
+  cursorPassageUuid,
+  cursorStart,
+  occurrenceIndex,
+  replaceText,
+  searchText,
+  targetUuids,
+  type = 'PASSAGE',
+}: {
+  client: GraphQLClient;
+  occurrenceIndex?: number;
+  replaceText: string;
+  searchText: string;
+  cursorPassageUuid?: string;
+  cursorStart?: number;
+  targetUuids: string[];
+  type?: ReplaceType;
+}) => {
+  const response = await client.request<ReplaceResponse>(REPLACE_MUTATION, {
+    searchText,
+    replaceText,
+    targetUuids,
+    type,
+    occurrenceIndex,
+    cursorPassageUuid,
+    cursorStart,
+  });
+
+  return response.replace;
+};

package/src/lib/generated/graphql.ts

@@ -115,94 +115,6 @@ export type FolioSide =
   | 'a'
   | 'b';
 
-/** Related entity for a glossary entry */
-export type GlossaryEntity = {
-  __typename?: 'GlossaryEntity';
-  /** Source entity headword */
-  sourceHeadword: Scalars['String']['output'];
-  /** Source entity UUID */
-  sourceUuid: Scalars['ID']['output'];
-  /** Target entity headword */
-  targetHeadword: Scalars['String']['output'];
-  /** Target entity UUID */
-  targetUuid: Scalars['ID']['output'];
-};
-
-/** Detailed glossary entry for the detail page */
-export type GlossaryEntry = {
-  __typename?: 'GlossaryEntry';
-  /** Authority UUID */
-  authorityUuid: Scalars['ID']['output'];
-  /** Chinese names */
-  chinese: Array<Scalars['String']['output']>;
-  /** Classifications/types */
-  classifications: Array<Scalars['String']['output']>;
-  /** Definition of the term */
-  definition?: Maybe<Scalars['String']['output']>;
-  /** English names/translations */
-  english: Array<Scalars['String']['output']>;
-  /** Primary headword */
-  headword: Scalars['String']['output'];
-  /** Primary language of the headword */
-  language: Scalars['String']['output'];
-  /** Pali names */
-  pali: Array<Scalars['String']['output']>;
-  /** Related entities */
-  relatedEntities: Array<GlossaryEntity>;
-  /** Related instances across works */
-  relatedInstances: Array<GlossaryInstance>;
-  /** Sanskrit names */
-  sanskrit: Array<Scalars['String']['output']>;
-  /** Tibetan names */
-  tibetan: Array<Scalars['String']['output']>;
-  /** XML ID from source */
-  xmlId?: Maybe<Scalars['String']['output']>;
-};
-
-/** A glossary instance appearing in a specific work */
-export type GlossaryInstance = {
-  __typename?: 'GlossaryInstance';
-  /** Canon the work belongs to */
-  canon?: Maybe<Scalars['String']['output']>;
-  /** Chinese names */
-  chinese: Array<Scalars['String']['output']>;
-  /** Creators/translators */
-  creators: Array<Scalars['String']['output']>;
-  /** Definition for this instance */
-  definition?: Maybe<Scalars['String']['output']>;
-  /** English names/translations */
-  english: Array<Scalars['String']['output']>;
-  /** Pali names */
-  pali: Array<Scalars['String']['output']>;
-  /** Sanskrit names */
-  sanskrit: Array<Scalars['String']['output']>;
-  /** Tibetan names */
-  tibetan: Array<Scalars['String']['output']>;
-  /** Tohoku catalog entry */
-  toh: Scalars['String']['output'];
-  /** UUID of the work containing this instance */
-  workUuid: Scalars['ID']['output'];
-};
-
-/** A glossary item for the landing page listing */
-export type GlossaryLandingItem = {
-  __typename?: 'GlossaryLandingItem';
-  /** Definition of the term */
-  definition: Scalars['String']['output'];
-  /** Primary headword for the term */
-  headword: Scalars['String']['output'];
-  /** Primary language of the headword */
-  language: Scalars['String']['output'];
-  /** Name variants for the term */
-  nameVariants: Scalars['String']['output'];
-  /** Number of glossary entries across works */
-  numGlossaryEntries: Scalars['Int']['output'];
-  /** Type/classification of the term */
-  type: Scalars['String']['output'];
-  /** Authority UUID */
-  uuid: Scalars['ID']['output'];
-};
-
 /** Paginated passage references for a glossary term */
 export type GlossaryPassagesPage = {
   __typename?: 'GlossaryPassagesPage';
@@ -214,6 +126,17 @@ export type GlossaryPassagesPage = {
   nextCursor?: Maybe<Scalars['String']['output']>;
 };
 
+/** Paginated connection of glossary term instances for a work */
+export type GlossaryTermConnection = {
+  __typename?: 'GlossaryTermConnection';
+  /** List of glossary term instances in this page */
+  nodes: Array<GlossaryTermInstance>;
+  /** Pagination information */
+  pageInfo: PageInfo;
+  /** Total number of glossary terms in this work */
+  totalCount: Scalars['Int']['output'];
+};
+
 /** A glossary term instance within a specific work */
 export type GlossaryTermInstance = {
   __typename?: 'GlossaryTermInstance';
@@ -223,12 +146,21 @@ export type GlossaryTermInstance = {
   definition?: Maybe<Scalars['String']['output']>;
   /** Names in different languages */
   names: GlossaryTermNames;
-  /** Passages where this term appears */
-  passages: Array<Passage>;
+  /** Paginated passage references where this term appears */
+  passages: GlossaryPassagesPage;
+  /** Absolute position of this term in the work's glossary (1-based) */
+  termNumber: Scalars['Int']['output'];
   /** Unique identifier */
   uuid: Scalars['ID']['output'];
 };
 
+
+/** A glossary term instance within a specific work */
+export type GlossaryTermInstancePassagesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
 /** Names for a glossary term instance in different languages */
 export type GlossaryTermNames = {
   __typename?: 'GlossaryTermNames';
@@ -302,6 +234,11 @@ export type Mutation = {
   __typename?: 'Mutation';
   /** Placeholder for schema validation - not used */
   _empty?: Maybe<Scalars['Boolean']['output']>;
+  /**
+   * Replace text within one or more targets.
+   * Requires editor.edit permission.
+   */
+  replace: ReplaceResult;
   /**
    * Save one or more passages.
    * Requires editor.edit permission.
@@ -310,6 +247,18 @@ export type Mutation = {
 };
 
 
+/** Root Mutation type - extend this in other schema files */
+export type MutationReplaceArgs = {
+  cursorPassageUuid?: InputMaybe<Scalars['ID']['input']>;
+  cursorStart?: InputMaybe<Scalars['Int']['input']>;
+  occurrenceIndex?: InputMaybe<Scalars['Int']['input']>;
+  replaceText: Scalars['String']['input'];
+  searchText: Scalars['String']['input'];
+  targetUuids: Array<Scalars['ID']['input']>;
+  type?: InputMaybe<ReplaceType>;
+};
+
+
 /** Root Mutation type - extend this in other schema files */
 export type MutationSavePassagesArgs = {
   deletedUuids?: InputMaybe<Array<Scalars['ID']['input']>>;
@@ -372,7 +321,7 @@ export type Passage = {
   uuid: Scalars['ID']['output'];
   /** UUID of the work this passage belongs to */
   workUuid: Scalars['ID']['output'];
-  /** XML ID from the source document */
+  /** The Legacy XML ID from the source document */
   xmlId?: Maybe<Scalars['String']['output']>;
 };
 
@@ -437,7 +386,7 @@ export type PassageInput = {
   uuid: Scalars['ID']['input'];
   /** UUID of the work this passage belongs to */
   workUuid: Scalars['ID']['input'];
-  /** XML ID from the source document */
+  /** The Legacy XML ID from the source document */
   xmlId?: InputMaybe<Scalars['String']['input']>;
 };
 
@@ -455,14 +404,10 @@ export type Query = {
   __typename?: 'Query';
   /** Get a single bibliography entry by UUID */
   bibliographyEntry?: Maybe<BibliographyEntryItem>;
-  /** Get a single glossary entry by UUID (for detail page) */
-  glossaryEntry?: Maybe<GlossaryEntry>;
   /** Get a single glossary instance by UUID */
   glossaryInstance?: Maybe<GlossaryTermInstance>;
   /** Get paginated passage references for a glossary term (per-term, on-demand) */
   glossaryTermPassages: GlossaryPassagesPage;
-  /** Get all glossary terms for the landing page */
-  glossaryTerms: Array<GlossaryLandingItem>;
   /**
    * Check if the current user has a specific permission.
    * Returns false if not authenticated.
@@ -472,7 +417,10 @@ export type Query = {
   health: HealthStatus;
   /** Get the currently authenticated user (null if not authenticated) */
   me?: Maybe<CurrentUser>;
-  /** Fetch a single passage by UUID */
+  /**
+   * Fetch a single passage by UUID or XML ID.
+   * At least one of uuid or legacy xmlId must be provided. Prefers uuid if both are present.
+   */
   passage?: Maybe<Passage>;
   /** Get the current API version */
   version: Scalars['String']['output'];
@@ -493,12 +441,6 @@ export type QueryBibliographyEntryArgs = {
 };
 
 
-/** Root Query type - extend this in other schema files */
-export type QueryGlossaryEntryArgs = {
-  uuid: Scalars['ID']['input'];
-};
-
-
 /** Root Query type - extend this in other schema files */
 export type QueryGlossaryInstanceArgs = {
   uuid: Scalars['ID']['input'];
@@ -513,12 +455,6 @@ export type QueryGlossaryTermPassagesArgs = {
 };
 
 
-/** Root Query type - extend this in other schema files */
-export type QueryGlossaryTermsArgs = {
-  uuids?: InputMaybe<Array<Scalars['ID']['input']>>;
-};
-
-
 /** Root Query type - extend this in other schema files */
 export type QueryHasPermissionArgs = {
   permission: Permission;
@@ -527,7 +463,8 @@ export type QueryHasPermissionArgs = {
 
 /** Root Query type - extend this in other schema files */
 export type QueryPassageArgs = {
-  uuid: Scalars['ID']['input'];
+  uuid?: InputMaybe<Scalars['ID']['input']>;
+  xmlId?: InputMaybe<Scalars['String']['input']>;
 };
 
 
@@ -545,6 +482,33 @@ export type QueryWorksArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
 };
 
+/** Result of a replace mutation */
+export type ReplaceResult = {
+  __typename?: 'ReplaceResult';
+  /** Number of annotations deleted because the replacement removed them */
+  deletedAnnotationCount: Scalars['Int']['output'];
+  /** Error message if the replace failed */
+  error?: Maybe<Scalars['String']['output']>;
+  /** Character offset within nextPassageUuid where the next single replace should continue */
+  nextOccurrenceStart?: Maybe<Scalars['Int']['output']>;
+  /** Passage UUID after which the next single replace should continue */
+  nextPassageUuid?: Maybe<Scalars['ID']['output']>;
+  /** Updated target passages for client-side refresh */
+  passages: Array<Passage>;
+  /** Number of occurrences replaced */
+  replacedOccurrenceCount: Scalars['Int']['output'];
+  /** Whether the replace was successful */
+  success: Scalars['Boolean']['output'];
+  /** Number of annotations whose ranges changed */
+  updatedAnnotationCount: Scalars['Int']['output'];
+  /** Number of target records updated */
+  updatedCount: Scalars['Int']['output'];
+};
+
+/** Supported target types for search-and-replace operations */
+export type ReplaceType =
+  | 'PASSAGE';
+
 /** Result of saving passages */
 export type SavePassagesResult = {
   __typename?: 'SavePassagesResult';
@@ -664,8 +628,13 @@ export type Work = {
   bibliography: Array<BibliographyEntry>;
   /** Folios for this work, filtered by toh and paginated */
   folios: Array<Folio>;
-  /** Glossary term instances for this work */
+  /**
+   * Glossary term instances for this work
+   * @deprecated Use glossaryTerms for paginated access
+   */
   glossary: Array<GlossaryTermInstance>;
+  /** Paginated glossary term instances for this work */
+  glossaryTerms: GlossaryTermConnection;
   /**
    * Publication imprint information.
    * If the work query specified a toh argument, that value will be used.
@@ -715,6 +684,15 @@ export type WorkGlossaryArgs = {
 };
 
 
+/** A published translation work from the 84000 canon */
+export type WorkGlossaryTermsArgs = {
+  cursor?: InputMaybe<Scalars['String']['input']>;
+  direction?: InputMaybe<PaginationDirection>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  withAttestations?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+
 /** A published translation work from the 84000 canon */
 export type WorkPassagesArgs = {
   cursor?: InputMaybe<Scalars['String']['input']>;
@@ -867,7 +845,8 @@ export type GetPassagesAroundWithJsonQuery = { __typename?: 'Query', work?: { __
       )>, pageInfo: { __typename?: 'PageInfo', nextCursor?: string | null, prevCursor?: string | null, hasMoreAfter: boolean, hasMoreBefore: boolean } } } | null };
 
 export type GetPassageQueryVariables = Exact<{
-  uuid: Scalars['ID']['input'];
+  uuid?: InputMaybe<Scalars['ID']['input']>;
+  xmlId?: InputMaybe<Scalars['String']['input']>;
 }>;
 
 
@@ -1183,8 +1162,8 @@ export const GetPassagesAroundWithJsonDocument = gql`
 }
     ${PassageWithJsonFragmentDoc}`;
 export const GetPassageDocument = gql`
-    query GetPassage($uuid: ID!) {
-  passage(uuid: $uuid) {
+    query GetPassage($uuid: ID, $xmlId: String) {
+  passage(uuid: $uuid, xmlId: $xmlId) {
     ...PassageWithAnnotations
   }
 }
@@ -1289,7 +1268,7 @@ export function getSdk(client: GraphQLClient, withWrapper: SdkFunctionWrapper =
     GetPassagesAroundWithJson(variables: GetPassagesAroundWithJsonQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetPassagesAroundWithJsonQuery> {
       return withWrapper((wrappedRequestHeaders) => client.request<GetPassagesAroundWithJsonQuery>({ document: GetPassagesAroundWithJsonDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetPassagesAroundWithJson', 'query', variables);
     },
-    GetPassage(variables: GetPassageQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetPassageQuery> {
+    GetPassage(variables?: GetPassageQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetPassageQuery> {
       return withWrapper((wrappedRequestHeaders) => client.request<GetPassageQuery>({ document: GetPassageDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetPassage', 'query', variables);
     },
     GetWorkByUuid(variables: GetWorkByUuidQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetWorkByUuidQuery> {

package/src/lib/graphql/queries/passages.graphql

@@ -109,8 +109,8 @@ query GetPassagesAroundWithJson(
   }
 }
 
-query GetPassage($uuid: ID!) {
-  passage(uuid: $uuid) {
+query GetPassage($uuid: ID, $xmlId: String) {
+  passage(uuid: $uuid, xmlId: $xmlId) {
     ...PassageWithAnnotations
   }
 }

package/src/ssr.ts

@@ -7,8 +7,6 @@ export {
 // Functions (same as browser)
 export {
   getPassage,
-  getTranslationPassages,
-  getTranslationPassagesAround,
   getTranslationBlocks,
   getTranslationBlocksAround,
   getTranslationTitles,
@@ -18,19 +16,14 @@ export {
   getTranslationUuids,
   getTranslationToc,
   getTranslationImprint,
-  getGlossaryTerms,
-  getGlossaryEntry,
   getGlossaryInstance,
-  getWorkGlossary,
   getWorkGlossaryTerms,
   getWorkGlossaryTermsAround,
   type GlossaryTermsPage,
   getBibliographyEntry,
   getWorkBibliography,
   getWorkFolios,
-  getWorks,
   type TranslationBlocksPage,
-  type WorksPage,
 } from './lib/functions';
 
 // Re-export types from @eightyfourthousand/data-access for convenience

package/src/lib/functions/get-glossary-entry.ts

@@ -1,136 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { GlossaryPageItem, TohokuCatalogEntry } from '@eightyfourthousand/data-access';
-
-const GET_GLOSSARY_ENTRY = gql`
-  query GetGlossaryEntry($uuid: ID!) {
-    glossaryEntry(uuid: $uuid) {
-      authorityUuid
-      headword
-      language
-      classifications
-      definition
-      xmlId
-      english
-      tibetan
-      sanskrit
-      pali
-      chinese
-      relatedInstances {
-        workUuid
-        toh
-        definition
-        canon
-        english
-        tibetan
-        sanskrit
-        pali
-        chinese
-        creators
-      }
-      relatedEntities {
-        sourceHeadword
-        sourceUuid
-        targetHeadword
-        targetUuid
-      }
-    }
-  }
-`;
-
-type GraphQLGlossaryEntry = {
-  authorityUuid: string;
-  headword: string;
-  language: string;
-  classifications: string[];
-  definition: string | null;
-  xmlId: string | null;
-  english: string[];
-  tibetan: string[];
-  sanskrit: string[];
-  pali: string[];
-  chinese: string[];
-  relatedInstances: Array<{
-    workUuid: string;
-    toh: string;
-    definition: string | null;
-    canon: string | null;
-    english: string[];
-    tibetan: string[];
-    sanskrit: string[];
-    pali: string[];
-    chinese: string[];
-    creators: string[];
-  }>;
-  relatedEntities: Array<{
-    sourceHeadword: string;
-    sourceUuid: string;
-    targetHeadword: string;
-    targetUuid: string;
-  }>;
-};
-
-type GetGlossaryEntryResponse = {
-  glossaryEntry: GraphQLGlossaryEntry | null;
-};
-
-/**
- * Map GraphQL glossary entry to the GlossaryPageItem type.
- */
-function glossaryEntryFromGraphQL(
-  entry: GraphQLGlossaryEntry,
-): GlossaryPageItem {
-  return {
-    authorityUuid: entry.authorityUuid,
-    headword: entry.headword,
-    language: entry.language as GlossaryPageItem['language'],
-    classifications: entry.classifications,
-    definition: entry.definition ?? undefined,
-    xmlId: entry.xmlId ?? undefined,
-    english: entry.english,
-    tibetan: entry.tibetan,
-    sanskrit: entry.sanskrit,
-    pali: entry.pali,
-    chinese: entry.chinese,
-    relatedInstances: entry.relatedInstances.map((instance) => ({
-      workUuid: instance.workUuid,
-      toh: instance.toh as TohokuCatalogEntry,
-      definition: instance.definition ?? undefined,
-      canon: instance.canon ?? undefined,
-      english: instance.english,
-      tibetan: instance.tibetan,
-      sanskrit: instance.sanskrit,
-      pali: instance.pali,
-      chinese: instance.chinese,
-      creators: instance.creators,
-    })),
-    relatedEntities: entry.relatedEntities,
-  };
-}
-
-/**
- * Get a single glossary entry by UUID (for the detail page).
- */
-export async function getGlossaryEntry({
-  client,
-  uuid,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-}): Promise<GlossaryPageItem | null> {
-  try {
-    const response = await client.request<GetGlossaryEntryResponse>(
-      GET_GLOSSARY_ENTRY,
-      { uuid },
-    );
-
-    if (!response.glossaryEntry) {
-      return null;
-    }
-
-    return glossaryEntryFromGraphQL(response.glossaryEntry);
-  } catch (error) {
-    console.error('Error fetching glossary entry:', error);
-    return null;
-  }
-}

package/src/lib/functions/get-glossary-terms.ts

@@ -1,44 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { GlossaryLandingItem } from '@eightyfourthousand/data-access';
-
-const GET_GLOSSARY_TERMS = gql`
-  query GetGlossaryTerms($uuids: [ID!]) {
-    glossaryTerms(uuids: $uuids) {
-      uuid
-      headword
-      type
-      language
-      nameVariants
-      definition
-      numGlossaryEntries
-    }
-  }
-`;
-
-type GetGlossaryTermsResponse = {
-  glossaryTerms: GlossaryLandingItem[];
-};
-
-/**
- * Get all glossary terms for the landing page, optionally filtered by UUIDs.
- */
-export async function getGlossaryTerms({
-  client,
-  uuids,
-}: {
-  client: GraphQLClient;
-  uuids?: string[];
-}): Promise<GlossaryLandingItem[]> {
-  try {
-    const response = await client.request<GetGlossaryTermsResponse>(
-      GET_GLOSSARY_TERMS,
-      { uuids },
-    );
-
-    return response.glossaryTerms;
-  } catch (error) {
-    console.error('Error fetching glossary terms:', error);
-    return [];
-  }
-}

package/src/lib/functions/get-translation-passages-around.ts

@@ -1,153 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { BodyItemType, PassagesPage } from '@eightyfourthousand/data-access';
-import { passagesPageFromGraphQL } from '../mappers';
-
-const GET_PASSAGES_AROUND = gql`
-  fragment AnnotationFields on Annotation {
-    uuid
-    type
-    start
-    end
-    metadata
-  }
-
-  fragment AlignmentFields on Alignment {
-    folioUuid
-    toh
-    tibetan
-    folioNumber
-    volumeNumber
-  }
-
-  fragment PassageWithAnnotations on Passage {
-    uuid
-    workUuid
-    content
-    label
-    sort
-    type
-    xmlId
-    annotations {
-      ...AnnotationFields
-    }
-    alignments {
-      ...AlignmentFields
-    }
-  }
-
-  query GetPassagesAround(
-    $uuid: ID!
-    $cursor: String!
-    $limit: Int
-    $filter: PassageFilter
-  ) {
-    work(uuid: $uuid) {
-      uuid
-      passages(
-        cursor: $cursor
-        limit: $limit
-        direction: AROUND
-        filter: $filter
-      ) {
-        nodes {
-          ...PassageWithAnnotations
-        }
-        pageInfo {
-          nextCursor
-          prevCursor
-          hasMoreAfter
-          hasMoreBefore
-        }
-      }
-    }
-  }
-`;
-
-type GetPassagesAroundResponse = {
-  work: {
-    uuid: string;
-    passages: {
-      nodes: Array<{
-        uuid: string;
-        workUuid: string;
-        content: string;
-        label: string;
-        sort: number;
-        type: string;
-        xmlId?: string | null;
-        annotations: Array<{
-          uuid: string;
-          type: string;
-          start: number;
-          end: number;
-          metadata?: Record<string, unknown> | null;
-        }>;
-        alignments: Array<{
-          folioUuid: string;
-          toh: string;
-          tibetan: string;
-          folioNumber: number;
-          volumeNumber: number;
-        }>;
-      }>;
-      pageInfo: {
-        nextCursor?: string | null;
-        prevCursor?: string | null;
-        hasMoreAfter: boolean;
-        hasMoreBefore: boolean;
-      };
-    };
-  } | null;
-};
-
-/**
- * Get passages around a specific passage UUID.
- *
- * NOTE: maxCharacters is not supported by the GraphQL API yet.
- * This parameter is accepted for API compatibility but is ignored.
- */
-export async function getTranslationPassagesAround({
-  client,
-  uuid,
-  passageUuid,
-  type,
-  maxPassages,
-  maxCharacters: _maxCharacters,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-  passageUuid: string;
-  type?: BodyItemType;
-  maxPassages?: number;
-  maxCharacters?: number;
-}): Promise<PassagesPage> {
-  try {
-    const response = await client.request<GetPassagesAroundResponse>(
-      GET_PASSAGES_AROUND,
-      {
-        uuid,
-        cursor: passageUuid,
-        limit: maxPassages,
-        filter: type ? { type } : undefined,
-      },
-    );
-
-    if (!response.work) {
-      return {
-        passages: [],
-        hasMoreAfter: false,
-        hasMoreBefore: false,
-      };
-    }
-
-    return passagesPageFromGraphQL(response.work.passages, response.work.uuid);
-  } catch (error) {
-    console.error('Error fetching translation passages around:', error);
-    return {
-      passages: [],
-      hasMoreAfter: false,
-      hasMoreBefore: false,
-    };
-  }
-}

package/src/lib/functions/get-translation-passages.ts

@@ -1,168 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type {
-  BodyItemType,
-  PaginationDirection,
-  PassagesPage,
-} from '@eightyfourthousand/data-access';
-import { passagesPageFromGraphQL } from '../mappers';
-
-const GET_PASSAGES = gql`
-  fragment AnnotationFields on Annotation {
-    uuid
-    type
-    start
-    end
-    metadata
-  }
-
-  fragment AlignmentFields on Alignment {
-    folioUuid
-    toh
-    tibetan
-    folioNumber
-    volumeNumber
-  }
-
-  fragment PassageWithAnnotations on Passage {
-    uuid
-    workUuid
-    content
-    label
-    sort
-    type
-    xmlId
-    annotations {
-      ...AnnotationFields
-    }
-    alignments {
-      ...AlignmentFields
-    }
-  }
-
-  query GetPassages(
-    $uuid: ID!
-    $cursor: String
-    $limit: Int
-    $direction: PaginationDirection
-    $filter: PassageFilter
-  ) {
-    work(uuid: $uuid) {
-      uuid
-      passages(
-        cursor: $cursor
-        limit: $limit
-        direction: $direction
-        filter: $filter
-      ) {
-        nodes {
-          ...PassageWithAnnotations
-        }
-        pageInfo {
-          nextCursor
-          prevCursor
-          hasMoreAfter
-          hasMoreBefore
-        }
-      }
-    }
-  }
-`;
-
-type GetPassagesResponse = {
-  work: {
-    uuid: string;
-    passages: {
-      nodes: Array<{
-        uuid: string;
-        workUuid: string;
-        content: string;
-        label: string;
-        sort: number;
-        type: string;
-        xmlId?: string | null;
-        annotations: Array<{
-          uuid: string;
-          type: string;
-          start: number;
-          end: number;
-          metadata?: Record<string, unknown> | null;
-        }>;
-        alignments: Array<{
-          folioUuid: string;
-          toh: string;
-          tibetan: string;
-          folioNumber: number;
-          volumeNumber: number;
-        }>;
-      }>;
-      pageInfo: {
-        nextCursor?: string | null;
-        prevCursor?: string | null;
-        hasMoreAfter: boolean;
-        hasMoreBefore: boolean;
-      };
-    };
-  } | null;
-};
-
-/**
- * Map internal pagination direction to GraphQL enum
- */
-function mapDirection(
-  direction?: PaginationDirection,
-): 'FORWARD' | 'BACKWARD' | undefined {
-  if (!direction) return undefined;
-  return direction === 'forward' ? 'FORWARD' : 'BACKWARD';
-}
-
-/**
- * Get paginated passages for a translation work.
- *
- * NOTE: maxCharacters is not supported by the GraphQL API yet.
- * This parameter is accepted for API compatibility but is ignored.
- */
-export async function getTranslationPassages({
-  client,
-  uuid,
-  type,
-  cursor,
-  maxPassages = 100,
-  maxCharacters: _maxCharacters,
-  direction,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-  type?: BodyItemType;
-  cursor?: string;
-  maxPassages?: number;
-  maxCharacters?: number;
-  direction?: PaginationDirection;
-}): Promise<PassagesPage> {
-  try {
-    const response = await client.request<GetPassagesResponse>(GET_PASSAGES, {
-      uuid,
-      cursor,
-      limit: maxPassages,
-      direction: mapDirection(direction),
-      filter: type ? { type } : undefined,
-    });
-
-    if (!response.work) {
-      return {
-        passages: [],
-        hasMoreAfter: false,
-        hasMoreBefore: false,
-      };
-    }
-
-    return passagesPageFromGraphQL(response.work.passages, response.work.uuid);
-  } catch (error) {
-    console.error('Error fetching translation passages:', error);
-    return {
-      passages: [],
-      hasMoreAfter: false,
-      hasMoreBefore: false,
-    };
-  }
-}

package/src/lib/functions/get-work-glossary.ts

@@ -1,54 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { GlossaryTermInstance } from '@eightyfourthousand/data-access';
-
-const GET_WORK_GLOSSARY = gql`
-  query GetWorkGlossary($uuid: ID!, $withAttestations: Boolean) {
-    work(uuid: $uuid) {
-      glossary(withAttestations: $withAttestations) {
-        uuid
-        authority
-        definition
-        names {
-          english
-          tibetan
-          sanskrit
-          pali
-          chinese
-          wylie
-        }
-      }
-    }
-  }
-`;
-
-type GetWorkGlossaryResponse = {
-  work: {
-    glossary: GlossaryTermInstance[];
-  } | null;
-};
-
-/**
- * Get glossary term instances for a specific work.
- */
-export async function getWorkGlossary({
-  client,
-  uuid,
-  withAttestations = false,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-  withAttestations?: boolean;
-}): Promise<GlossaryTermInstance[]> {
-  try {
-    const response = await client.request<GetWorkGlossaryResponse>(
-      GET_WORK_GLOSSARY,
-      { uuid, withAttestations },
-    );
-
-    return response.work?.glossary ?? [];
-  } catch (error) {
-    console.error('Error fetching work glossary:', error);
-    return [];
-  }
-}

package/src/lib/functions/get-works.ts

@@ -1,111 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { Work } from '@eightyfourthousand/data-access';
-
-const GET_WORKS = gql`
-  query GetWorks($cursor: String, $limit: Int) {
-    works(cursor: $cursor, limit: $limit) {
-      items {
-        uuid
-        title
-        toh
-        publicationDate
-        publicationVersion
-        pages
-        restriction
-        section
-      }
-      pageInfo {
-        nextCursor
-        prevCursor
-        hasMoreAfter
-        hasMoreBefore
-      }
-      totalCount
-    }
-  }
-`;
-
-type GraphQLWork = {
-  uuid: string;
-  title: string;
-  toh: string[];
-  publicationDate: string;
-  publicationVersion: string;
-  pages: number;
-  restriction: boolean;
-  section: string;
-};
-
-type PageInfo = {
-  nextCursor: string | null;
-  prevCursor: string | null;
-  hasMoreAfter: boolean;
-  hasMoreBefore: boolean;
-};
-
-type GetWorksResponse = {
-  works: {
-    items: GraphQLWork[];
-    pageInfo: PageInfo;
-    totalCount: number;
-  };
-};
-
-export type WorksPage = {
-  items: Work[];
-  pageInfo: PageInfo;
-  totalCount: number;
-};
-
-function workFromGraphQL(gqlWork: GraphQLWork): Work {
-  return {
-    uuid: gqlWork.uuid,
-    title: gqlWork.title,
-    toh: gqlWork.toh as Work['toh'],
-    publicationDate: new Date(gqlWork.publicationDate),
-    publicationVersion:
-      gqlWork.publicationVersion as Work['publicationVersion'],
-    pages: gqlWork.pages,
-    restriction: gqlWork.restriction,
-    section: gqlWork.section,
-  };
-}
-
-/**
- * Get paginated works.
- */
-export async function getWorks({
-  client,
-  cursor,
-  limit = 50,
-}: {
-  client: GraphQLClient;
-  cursor?: string;
-  limit?: number;
-}): Promise<WorksPage> {
-  try {
-    const response = await client.request<GetWorksResponse>(GET_WORKS, {
-      cursor,
-      limit,
-    });
-
-    return {
-      items: response.works.items.map(workFromGraphQL),
-      pageInfo: response.works.pageInfo,
-      totalCount: response.works.totalCount,
-    };
-  } catch (error) {
-    console.error('Error fetching works:', error);
-    return {
-      items: [],
-      pageInfo: {
-        nextCursor: null,
-        prevCursor: null,
-        hasMoreAfter: false,
-        hasMoreBefore: false,
-      },
-      totalCount: 0,
-    };
-  }
-}