polen 0.11.0-next.16 → 0.11.0-next.17

package/src/api/examples/diagnostic/validator.ts

@@ -1,8 +1,8 @@
 import { Catalog as SchemaCatalog } from '#lib/catalog/$'
 import { Document } from '#lib/document/$'
 import { Version } from '#lib/version/$'
-import { HashMap, Match, Option } from 'effect'
-import { Array } from 'effect'
+import { Match } from 'effect'
+import { HashMap } from 'effect/Schema'
 import type { GraphQLError, GraphQLSchema } from 'graphql'
 import { parse, specifiedRules, validate } from 'graphql'
 import { Example } from '../schemas/example/$.js'
@@ -35,23 +35,21 @@ export const validateExamples = (
   return Match.value(catalog).pipe(
     Match.tagsExhaustive({
       CatalogVersioned: (versioned) => {
-        const schemaVersions = versioned.entries.map(e => e.version)
-
         for (const example of examples) {
           Match.value(example.document).pipe(
             Match.tagsExhaustive({
               DocumentVersioned: (doc) => {
                 // Validate each version against its corresponding schema
-                for (const entry of versioned.entries) {
-                  const content = Document.Versioned.getContentForVersion(doc, entry.version)
+                for (const schema of SchemaCatalog.Versioned.getAll(versioned)) {
+                  const content = Document.Versioned.getContentForVersion(doc, schema.version)
                   if (content) {
-                    const versionStr = Version.encodeSync(entry.version)
+                    const versionStr = Version.encodeSync(schema.version)
                     validateDocument(
                       example.name,
                       example.path,
                       versionStr,
                       content,
-                      entry.definition,
+                      schema.definition,
                       diagnostics,
                     )
                   }
@@ -59,7 +57,7 @@ export const validateExamples = (
                 return undefined
               },
               DocumentUnversioned: (doc) => {
-                const latestEntry = versioned.entries[0]!
+                const latestEntry = SchemaCatalog.Versioned.getLatestOrThrow(versioned)
                 validateDocument(
                   example.name,
                   example.path,

package/src/api/examples/scanner.ts

@@ -91,10 +91,10 @@ const lintFileLayout = (
   schemaCatalog?: SchemaCatalog.Catalog,
 ): Diagnostic[] => {
   // Extract schema versions from catalog if provided
-  const schemaVersions: string[] = schemaCatalog
+  const schemaVersions: Version.Version[] = schemaCatalog
     ? SchemaCatalog.fold(
-      (versioned) => versioned.entries.map(entry => Version.encodeSync(entry.version)),
-      (unversioned) => unversioned.schema.revisions?.map(r => r.date) ?? [],
+      (versioned) => SchemaCatalog.Versioned.getVersions(versioned),
+      (unversioned) => [], // Unversioned doesn't have Version objects, just dates
     )(schemaCatalog)
     : []
 
@@ -105,14 +105,13 @@ const lintFileLayout = (
       DocumentVersioned: (doc) => {
         // Get all versions covered by this document
         const coveredVersions = Document.Versioned.getAllVersions(doc)
-        const coveredVersionStrings = coveredVersions.map(Version.encodeSync)
-        const missingVersions = schemaVersions.filter(sv => !coveredVersionStrings.includes(sv))
+        const missingVersions = schemaVersions.filter(sv => !coveredVersions.some(cv => Version.equivalence(sv, cv)))
 
         if (missingVersions.length > 0) {
           diagnostics.push(makeDiagnosticMissingVersions({
             message: `Versioned example must provide documents for all schema versions`,
             example: { name: example.name, path: example.path },
-            providedVersions: coveredVersionStrings,
+            providedVersions: coveredVersions,
             missingVersions,
           }))
         }
@@ -206,7 +205,7 @@ export const scan = (
         // Get all schema versions to map to this default document
         const schemaVersions: Version.Version[] = options.schemaCatalog
           ? SchemaCatalog.fold(
-            (versioned) => versioned.entries.map(entry => entry.version),
+            (versioned) => SchemaCatalog.Versioned.getVersions(versioned),
             () => [], // Unversioned schemas don't have version-specific examples
           )(options.schemaCatalog)
           : []
@@ -238,16 +237,19 @@ export const scan = (
         // Versioned example - multiple files or versioned files
         let versionDocuments = HashMap.empty<VersionCoverage.VersionCoverage, string>()
         let defaultDocument: string | undefined
-        const explicitVersions = new Set<string>() // Track which versions have explicit files
-        const unknownVersions: string[] = []
+        let explicitVersions = HashSet.empty<Version.Version>() // Track which versions have explicit files
+        const unknownVersions: Version.Version[] = []
 
         // Get available schema versions if catalog is provided
-        const schemaVersions: string[] = options.schemaCatalog
+        const schemaVersions: Version.Version[] = options.schemaCatalog
           ? SchemaCatalog.fold(
-            (versioned) => versioned.entries.map(entry => Version.encodeSync(entry.version)),
+            (versioned) => SchemaCatalog.Versioned.getVersions(versioned),
             () => [], // Unversioned schemas don't have version-specific examples
           )(options.schemaCatalog)
           : []
+        
+        // Create HashSet for O(1) lookups
+        const schemaVersionsSet = HashSet.fromIterable(schemaVersions)
 
         // Read content for each version
         for (const [version, filePath] of versions) {
@@ -257,35 +259,38 @@ export const scan = (
           if (version === 'default') {
             defaultDocument = fileContent
           } else if (version !== null) {
+            // Parse the version string
+            const parsedVersion = Version.decodeSync(version)
             // Check if this version exists in the schema
-            if (options.schemaCatalog && schemaVersions.length > 0 && !schemaVersions.includes(version)) {
-              unknownVersions.push(version)
+            const versionExists = HashSet.has(schemaVersionsSet, parsedVersion)
+            if (options.schemaCatalog && schemaVersions.length > 0 && !versionExists) {
+              unknownVersions.push(parsedVersion)
               // Create diagnostic for unknown version
               diagnostics.push(makeDiagnosticUnknownVersion({
                 message: `Example "${name}" specifies version "${version}" which does not exist in the schema`,
                 example: { name, path: basePath },
-                version,
+                version: parsedVersion,
                 availableVersions: schemaVersions,
               }))
               // Skip this version - don't include it in the example
               continue
             }
 
-            const versionObj = Version.decodeSync(version)
-            versionDocuments = HashMap.set(versionDocuments, versionObj, fileContent)
-            explicitVersions.add(version)
+            // We already have parsedVersion from above
+            versionDocuments = HashMap.set(versionDocuments, parsedVersion, fileContent)
+            explicitVersions = HashSet.add(explicitVersions, parsedVersion)
           }
         }
 
         if (defaultDocument) {
           // If we have a default, determine which versions it applies to
-          const defaultVersions = schemaVersions.filter(v => !explicitVersions.has(v))
+          const defaultVersions = schemaVersions.filter(v => !HashSet.has(explicitVersions, v))
 
           if (defaultVersions.length > 0) {
             // Create a version set for the default document
             const defaultVersionSet = defaultVersions.length === 1
-              ? Version.decodeSync(defaultVersions[0]!) // Single version
-              : HashSet.fromIterable(defaultVersions.map(_ => Version.decodeSync(_))) // Version set
+              ? defaultVersions[0]! // Single version
+              : HashSet.fromIterable(defaultVersions) // Version set
 
             versionDocuments = HashMap.set(versionDocuments, defaultVersionSet, defaultDocument)
           }

package/src/api/examples/type-usage-indexer.test.ts

@@ -1,6 +1,5 @@
 import { Catalog } from '#lib/catalog/$'
 import { Document } from '#lib/document/$'
-import { Revision } from '#lib/revision/$'
 import { Schema } from '#lib/schema/$'
 import { Version } from '#lib/version/$'
 import { HashMap, HashSet, Schema as S } from 'effect'
@@ -17,23 +16,23 @@ describe('type-usage-indexer', () => {
       users: [User!]!
       product(id: ID!): Product
     }
-    
+
     type User {
       id: ID!
       name: String!
       email: String!
     }
-    
+
     type Product {
       id: ID!
       name: String!
       price: Float!
     }
-    
+
     interface Node {
       id: ID!
     }
-    
+
     union SearchResult = User | Product
   `
 
@@ -91,20 +90,26 @@ describe('type-usage-indexer', () => {
       })
 
       const catalog = Catalog.Versioned.make({
-        entries: [
-          Schema.Versioned.make({
-            version: version1,
-            definition: schemaDef,
-            branchPoint: null,
-            revisions: [],
-          }),
-          Schema.Versioned.make({
-            version: version2,
-            definition: schemaDef,
-            branchPoint: null,
-            revisions: [],
-          }),
-        ],
+        entries: HashMap.make(
+          [
+            version1,
+            Schema.Versioned.make({
+              version: version1,
+              definition: schemaDef,
+              branchPoint: null,
+              revisions: [],
+            }),
+          ],
+          [
+            version2,
+            Schema.Versioned.make({
+              version: version2,
+              definition: schemaDef,
+              branchPoint: null,
+              revisions: [],
+            }),
+          ],
+        ),
       })
 
       const index = createTypeUsageIndex([example], catalog)
@@ -212,20 +217,26 @@ describe('type-usage-indexer', () => {
       })
 
       const catalog = Catalog.Versioned.make({
-        entries: [
-          Schema.Versioned.make({
-            version: version1,
-            definition: schemaDef,
-            branchPoint: null,
-            revisions: [],
-          }),
-          Schema.Versioned.make({
-            version: version2,
-            definition: schemaDef,
-            branchPoint: null,
-            revisions: [],
-          }),
-        ],
+        entries: HashMap.make(
+          [
+            version1,
+            Schema.Versioned.make({
+              version: version1,
+              definition: schemaDef,
+              branchPoint: null,
+              revisions: [],
+            }),
+          ],
+          [
+            version2,
+            Schema.Versioned.make({
+              version: version2,
+              definition: schemaDef,
+              branchPoint: null,
+              revisions: [],
+            }),
+          ],
+        ),
       })
 
       const index = createTypeUsageIndex([example], catalog)

package/src/api/examples/type-usage-indexer.ts

@@ -172,11 +172,8 @@ const getSchemaByVersion = (
   version: Version.Version,
 ): Schema.Schema | undefined => {
   if (Catalog.Versioned.is(catalog)) {
-    // Find the schema with matching version
-    return catalog.entries.find(entry =>
-      Schema.Versioned.is(entry)
-      && Version.equivalence(entry.version, version)
-    )
+    // Use HashMap.get for O(1) lookup
+    return HashMap.get(catalog.entries, version).pipe(Option.getOrElse(() => undefined))
   }
   // For unversioned catalog, return the single schema if version matches
   if (Catalog.Unversioned.is(catalog)) {
@@ -206,12 +203,12 @@ export const createTypeUsageIndex = (
     // Process based on document type
     if (Document.Unversioned.is(example.document)) {
       // Unversioned document
-      const schema = Catalog.getLatestSchema(schemasCatalog)
+      const schema = Catalog.getLatest(schemasCatalog)
       const types = extractTypesFromQuery(example.document.document, schema.definition)
 
       for (const typeName of types) {
         // For unversioned, use the latest version from the catalog
-        const latestVersion = Catalog.getLatestVersionIdentifier(schemasCatalog) ?? Version.fromString('1.0.0')
+        const latestVersion = Catalog.getLatestVersion(schemasCatalog) ?? Version.fromString('1.0.0')
         index = addExampleToIndex(index, UNVERSIONED_KEY, typeName, example, latestVersion)
       }
     } else if (Document.Versioned.is(example.document)) {

package/src/api/schema/$.test.ts

@@ -3,7 +3,7 @@ import { Catalog } from '#lib/catalog/$'
 import { Grafaid } from '#lib/grafaid'
 import { MemoryFilesystem } from '#lib/memory-filesystem/$'
 import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
-import { Effect } from 'effect'
+import { Effect, HashMap } from 'effect'
 import { expect } from 'vitest'
 import { Test } from '../../../tests/unit/helpers/test.js'
 import { Schema } from './$.js'
@@ -421,7 +421,7 @@ testWithFileSystem<BaseTestCase & {
         expect(result!._tag).toBe('CatalogVersioned')
         if (expected.versionCount !== undefined) {
           const versioned = result as Catalog.Versioned.Versioned
-          expect(versioned.entries.length).toBe(expected.versionCount)
+          expect(HashMap.size(versioned.entries)).toBe(expected.versionCount)
         }
       } else {
         expect(result!._tag).toBe('CatalogUnversioned')

package/src/api/schema/input-sources/versioned-directory.ts

@@ -10,7 +10,7 @@ import { debugPolen } from '#singletons/debug'
 import { PlatformError } from '@effect/platform/Error'
 import { FileSystem } from '@effect/platform/FileSystem'
 import { Arr, Path } from '@wollybeard/kit'
-import { Effect } from 'effect'
+import { Effect, HashMap } from 'effect'
 import type { GraphQLSchema } from 'graphql'
 
 const debug = debugPolen.sub(`schema:data-source-versioned-schema-directory`)
@@ -393,9 +393,14 @@ export const readOrThrow = (
     // Reverse to have newest first
     catalogEntries.reverse()
 
+    // Convert array to HashMap with version as key
+    const entriesMap = HashMap.fromIterable(
+      catalogEntries.map(entry => [entry.version, entry] as const),
+    )
+
     debug(`computed ${catalogEntries.length} entries`)
     return Catalog.Versioned.make({
-      entries: catalogEntries,
+      entries: entriesMap,
     })
   })
 

package/src/api/schema/load.ts

@@ -142,7 +142,7 @@ export const loadOrNull = (
       const catalog = loadedSchema.data as Catalog.Catalog
       Catalog.fold(
         (versioned) => {
-          for (const schema of versioned.entries) {
+          for (const schema of Catalog.Versioned.getAll(versioned)) {
             Augmentations.apply(schema.definition, augmentations)
           }
         },

package/src/cli/commands/hero-image.ts

@@ -133,7 +133,7 @@ export const heroImage = Command.make(
       const schemaResult = yield* Api.Schema.loadOrNull(config)
       if (schemaResult?.data) {
         try {
-          const latestSchema = Catalog.getLatestSchema(schemaResult.data)
+          const latestSchema = Catalog.getLatest(schemaResult.data)
           if (latestSchema?.definition) {
             schema = latestSchema.definition
             const context = AiImageGeneration.analyzeSchema(schema)

package/src/lib/catalog/catalog.ts

@@ -1,7 +1,7 @@
 import { S } from '#lib/kit-temp/effect'
 import { Schema } from '#lib/schema/$'
 import { Version } from '#lib/version/$'
-import { Match } from 'effect'
+import { HashMap, Match } from 'effect'
 import * as Unversioned from './unversioned.js'
 import * as Versioned from './versioned.js'
 
@@ -62,7 +62,7 @@ export const equivalence = S.equivalence(Catalog)
  */
 export const getVersionCount = (catalog: Catalog): number =>
   fold(
-    (versioned) => versioned.entries.length,
+    (versioned) => HashMap.size(versioned.entries),
     (_unversioned) => 1, // Unversioned catalog is effectively one version
   )(catalog)
 
@@ -79,28 +79,22 @@ export const getSchemaVersionString = (schema: Schema.Schema): string => {
  * Get the version string from a schema.
  * Returns the stringified version for versioned schemas, or '__UNVERSIONED__' for unversioned schemas.
  */
-export const getLatestSchema = (catalog: Catalog): Schema.Schema =>
+export const getLatest = (catalog: Catalog): Schema.Schema =>
   Match.value(catalog).pipe(Match.tagsExhaustive({
-    CatalogVersioned: (versioned) => {
-      // Entries are sorted newest first, so get the first entry
-      const latestEntry = versioned.entries[0]!
-      return latestEntry
-    },
-    CatalogUnversioned: (unversioned) => {
-      return unversioned.schema
-    },
+    CatalogVersioned: Versioned.getLatestOrThrow,
+    CatalogUnversioned: (unversioned) => unversioned.schema,
   }))
 
 /**
  * Get the latest version identifier from a catalog.
  * Returns the version for versioned catalogs, or null for unversioned catalogs.
  */
-export const getLatestVersionIdentifier = (catalog?: Catalog): Version.Version | null => {
+export const getLatestVersion = (catalog?: Catalog): Version.Version | null => {
   if (!catalog) return null
   return Match.value(catalog).pipe(
     Match.tagsExhaustive({
       CatalogUnversioned: () => null,
-      CatalogVersioned: (cat) => cat.entries[0]?.version ?? null,
+      CatalogVersioned: (cat) => Versioned.getVersions(cat)[0] ?? null,
     }),
   )
 }

package/src/lib/catalog/versioned.ts

@@ -1,12 +1,17 @@
 import { S } from '#lib/kit-temp/effect'
+import { Array, HashMap, Iterable, Order, pipe } from 'effect'
 import { Schema } from '../schema/$.js'
+import { Version } from '../version/$.js'
 
 // ============================================================================
 // Schema
 // ============================================================================
 
 export const Versioned = S.TaggedStruct('CatalogVersioned', {
-  entries: S.Array(Schema.Versioned.Versioned),
+  entries: S.HashMap({
+    key: Version.Version,
+    value: Schema.Versioned.Versioned,
+  }),
 }).annotations({
   identifier: 'CatalogVersioned',
   title: 'Versioned Catalog',
@@ -47,16 +52,40 @@ export const equivalence = S.equivalence(Versioned)
 
 /**
  * Get the latest schema definition from a versioned catalog.
- * The latest version is the first entry in the catalog (entries are ordered newest to oldest).
+ * The latest version is determined by Version.max comparison.
  *
  * @param catalog - The versioned catalog
  * @returns The GraphQL schema definition of the latest version
  * @throws {Error} If the catalog has no entries
  */
-export const getLatest = (catalog: Versioned): Schema.Schema => {
-  const latestEntry = catalog.entries[0]
-  if (!latestEntry) {
+export const getLatestOrThrow = (catalog: Versioned): Schema.Versioned.Versioned => {
+  const schema = getAll(catalog)[0]
+  if (!schema) {
     throw new Error('Versioned catalog has no entries - cannot get latest schema')
   }
-  return latestEntry
+  return schema
+}
+
+/**
+ * Get all schemas sorted by version (newest first)
+ */
+export const getAll = (catalog: Versioned): Schema.Versioned.Versioned[] => {
+  return pipe(
+    catalog.entries,
+    HashMap.values,
+    Array.fromIterable,
+    // Put newest versions first in array
+    Array.sort(Order.reverse(Schema.Versioned.order)),
+  )
+}
+
+/**
+ * Get all versions sorted (newest first)
+ */
+export const getVersions = (catalog: Versioned): Version.Version[] => {
+  return pipe(
+    catalog,
+    getAll,
+    Array.map(_ => _.version),
+  )
 }

package/src/lib/catalog-statistics/$.test.ts

@@ -1,6 +1,7 @@
 import { Catalog } from '#lib/catalog/$'
 import { DateOnly } from '#lib/date-only/$'
 import { Version } from '#lib/version/$'
+import { HashMap } from 'effect'
 import { buildSchema, type GraphQLSchema } from 'graphql'
 import { describe, expect, test } from 'vitest'
 import { CatalogStatistics } from './$.js'
@@ -91,14 +92,20 @@ describe('analyzeCatalog', () => {
       name: 'versioned catalog',
       catalog: () =>
         Catalog.Versioned.make({
-          entries: [
-            makeVersionedEntry(1, buildSchema('type Query { hello: String }'), ['2024-01-01', '2024-01-15']),
-            makeVersionedEntry(
-              2,
-              buildSchema('type Query { hello: String, world: String } type User { id: ID!, name: String }'),
-              ['2024-02-01'],
-            ),
-          ],
+          entries: HashMap.make(
+            [
+              Version.fromInteger(1),
+              makeVersionedEntry(1, buildSchema('type Query { hello: String }'), ['2024-01-01', '2024-01-15']),
+            ],
+            [
+              Version.fromInteger(2),
+              makeVersionedEntry(
+                2,
+                buildSchema('type Query { hello: String, world: String } type User { id: ID!, name: String }'),
+                ['2024-02-01'],
+              ),
+            ],
+          ),
         }),
       expectedVersions: 2,
       expectedCurrentVersion: '2',
@@ -132,10 +139,13 @@ describe('analyzeCatalog', () => {
 
   test('calculates stability metrics', () => {
     const catalog = Catalog.Versioned.make({
-      entries: [
-        makeVersionedEntry(1, buildSchema('type Query { test: String }'), ['2024-01-01', '2024-01-05']),
-        makeVersionedEntry(2, buildSchema('type Query { test: String }'), ['2024-01-10']),
-      ],
+      entries: HashMap.make(
+        [
+          Version.fromInteger(1),
+          makeVersionedEntry(1, buildSchema('type Query { test: String }'), ['2024-01-01', '2024-01-05']),
+        ],
+        [Version.fromInteger(2), makeVersionedEntry(2, buildSchema('type Query { test: String }'), ['2024-01-10'])],
+      ),
     })
 
     const report = CatalogStatistics.analyzeCatalog(catalog)

package/src/lib/catalog-statistics/analyze-catalog.ts

@@ -16,7 +16,7 @@ export const analyzeCatalog = (catalog: Catalog.Catalog, options: AnalyzeOptions
   const processResult = Catalog.fold(
     // Versioned catalog
     (versioned) => {
-      for (const entry of versioned.entries) {
+      for (const entry of Catalog.Versioned.getAll(versioned)) {
         const versionId = Version.encodeSync(entry.version)
         // Analyze the schema definition for this version
         // Use the first revision date if available
@@ -55,8 +55,8 @@ export const analyzeCatalog = (catalog: Catalog.Catalog, options: AnalyzeOptions
   // Calculate stability metrics
   const stability = calculateStabilityMetrics(versions, revisionDates)
 
-  // Get current version (last in array)
-  const current = versions[versions.length - 1]
+  // Get current version (first in array since sorted newest first)
+  const current = versions[0]
 
   return {
     stability,

package/src/lib/lifecycles/lifecycles.ts

@@ -119,7 +119,7 @@ export const create = (catalog: Catalog.Catalog): Lifecycles => {
   Catalog.fold(
     // Versioned catalog - process each versioned schema
     (versioned) => {
-      for (const schema of versioned.entries) {
+      for (const schema of Catalog.Versioned.getAll(versioned)) {
         processSchema(schema)
       }
     },

package/src/template/components/Changelog/Changelog.tsx

@@ -4,6 +4,7 @@ import { DateOnly } from '#lib/date-only/$'
 import { Revision } from '#lib/revision/$'
 import { Schema } from '#lib/schema/$'
 import { Version } from '#lib/version/$'
+import { HashMap, Option } from 'effect'
 const CRITICALITY_LEVELS = ['BREAKING', 'DANGEROUS', 'NON_BREAKING'] as const
 import type { CriticalityLevel } from '@graphql-inspector/core'
 import { Box, Heading } from '@radix-ui/themes'
@@ -35,8 +36,7 @@ export const Changelog: React.FC<{ catalog: Catalog.Catalog }> = ({ catalog }) =
   useEffect(() => {
     if (urlVersion) return
     if (Catalog.Unversioned.is(catalog)) return
-    const latestSchema = catalog.entries[0]
-    if (!latestSchema) return
+    const latestSchema = Catalog.Versioned.getLatestOrThrow(catalog)
     const latestVersion = Version.encodeSync(latestSchema.version)
     navigate(`/changelog/version/${latestVersion}`, { replace: true })
   }, [catalog, urlVersion, navigate])
@@ -51,10 +51,14 @@ export const Changelog: React.FC<{ catalog: Catalog.Catalog }> = ({ catalog }) =
     } else {
       // For versioned catalogs, always show specific version (never all)
       if (urlVersion) {
-        const entry = catalog.entries.find(e => Version.encodeSync(e.version) === urlVersion)
-        return entry
-          ? { revisions: entry.revisions, schema: entry }
-          : { revisions: [], schema: null }
+        const entryOption = Option.map(
+          HashMap.findFirst(catalog.entries, (_, key) => Version.encodeSync(key) === urlVersion),
+          ([, value]) => value,
+        )
+        return Option.match(entryOption, {
+          onNone: () => ({ revisions: [], schema: null }),
+          onSome: (entry) => ({ revisions: entry.revisions, schema: entry }),
+        })
       }
       // This shouldn't happen due to redirect above, but return empty as fallback
       return { revisions: [], schema: null }

package/src/template/components/GraphQLDocument.tsx

@@ -5,7 +5,7 @@ import type { Schema } from '#lib/schema/$'
 import { VersionCoverage } from '#lib/version-selection/$'
 import { VersionCoverageSet } from '#lib/version-selection/version-selection'
 import { Version } from '#lib/version/$'
-import { Array, HashMap, Match } from 'effect'
+import { Array, HashMap, Match, Option } from 'effect'
 import type { GraphQLSchema } from 'graphql'
 import * as React from 'react'
 import { useHighlighted } from '../hooks/use-highlighted.js'
@@ -47,7 +47,7 @@ export const GraphQLDocument: React.FC<GraphQLDocumentProps> = ({
   /// ━ VERSION MANAGEMENT
   const isControlled = controlledVersionCoverage !== undefined
   const [internalVersionCoverage, setInternalVersionCoverage] = React.useState<VersionCoverage.VersionCoverage | null>(
-    Catalog.getLatestVersionIdentifier(schemaCatalog),
+    Catalog.getLatestVersion(schemaCatalog),
   )
   const selectedVersionCoverage = isControlled ? controlledVersionCoverage : internalVersionCoverage
   const internalOnVersionChange = (version: VersionCoverage.VersionCoverage) => {
@@ -110,7 +110,7 @@ const resolveSelectedVerCov = (
       schema: Match.value(schemaCatalog).pipe(
         Match.tagsExhaustive({
           CatalogUnversioned: (catalog) => catalog.schema,
-          CatalogVersioned: (catalog) => Catalog.Versioned.getLatest(catalog),
+          CatalogVersioned: (catalog) => Catalog.Versioned.getLatestOrThrow(catalog),
         }),
       ),
     }
@@ -134,10 +134,11 @@ const resolveSelectedVerCov = (
       if (Catalog.Unversioned.is(schemaCatalog)) {
         throw new Error('Cannot use a set of versions with an unversioned catalog')
       }
-      const schema = schemaCatalog.entries.find(e => Version.equivalence(e.version, version))
-      if (!schema) {
+      const schemaOption = HashMap.get(schemaCatalog.entries, version)
+      if (Option.isNone(schemaOption)) {
         throw new Error(`Version ${Version.encodeSync(version)} not found in catalog`)
       }
+      const schema = Option.getOrThrow(schemaOption)
 
       return { content, schema: schema }
     }),