@aephia/atlas-kit 0.6.0-next.98 → 0.6.0

package/dist/registry/index.js

@@ -7,7 +7,7 @@ import { isAddress } from '@solana/kit';
 import { AccountNotFoundError, MissingGameContextError, InvalidDefinitionSectionError, ProviderError, RegistryOutOfSyncError, } from '../client/errors.js';
 import { assertContextActive, waitForRegistry } from '../client/lifecycle.js';
 import { deepFreeze, validateImmutableTree, } from '../internal/immutable-tree.js';
-import { decodeGameRegistrySections, } from '../internal/c4/game.js';
+import { decodeRegistryGame, gameBuildingsRegistrySection, gameCargoRegistrySection, gameClaimStakesRegistrySection, gameCraftingHabsRegistrySection, gameHabBuildingsRegistrySection, gameResearchRegistrySection, gameShipsRegistrySection, gameXpRegistrySection, } from '../internal/c4/game.js';
 const SEQUENCE_MISMATCH_RETRY_DELAY_MS = 1_000;
 // D029/D055 tolerate newer ship definitions for older callers; the resolved
 // definitionSequenceId exposes that skew. Every other section remains strict.
@@ -41,12 +41,6 @@ function freezeShips(definitions, sequenceId) {
         return Object.freeze(attachJsonSerialization({ ...value }));
     }));
 }
-function isPersistedDefinitionSection(section) {
-    return (section === 'claimStakes' ||
-        section === 'buildings' ||
-        section === 'craftingHabs' ||
-        section === 'habBuildings');
-}
 function freezeCatalog(data) {
     const catalog = Object.freeze(data.definitions.map((definition) => Object.freeze(attachJsonSerialization({ ...deepFreeze(definition) }))));
     return {
@@ -55,45 +49,22 @@ function freezeCatalog(data) {
         sequenceId: data.sequenceId,
     };
 }
-function sectionFromGame(game, section) {
-    if (isPersistedDefinitionSection(section)) {
-        return freezeCatalog(game);
-    }
-    if (section === 'xp') {
-        const definitions = freezeDefinitions([
-            game,
-        ]);
-        return {
-            definitions: new Map([[0, definitions[0]]]),
-            sequenceId: definitions[0].sequenceId,
-        };
-    }
-    if (section === 'research') {
-        const research = game;
-        const definitions = freezeDefinitions(research.nodes);
-        return {
-            definitions: new Map(definitions.map((definition) => [definition.id, definition])),
-            sequenceId: research.sequenceId,
-        };
-    }
-    if (section === 'ships') {
-        const ships = game;
-        const definitions = freezeShips(ships.definitions, ships.sequenceId);
-        const loaded = {
-            configurations: definitions,
-            definitions: new Map(definitions.map((definition) => [definition.id, definition])),
-            sequenceId: ships.sequenceId,
-        };
-        return loaded;
-    }
-    const values = game;
-    const definitions = freezeDefinitions(values.definitions);
+function idSection(values, sequenceId) {
+    const definitions = freezeDefinitions(values);
     return {
         definitions: new Map(definitions.map((definition) => [definition.id, definition])),
-        sequenceId: values.sequenceId,
+        sequenceId,
     };
 }
-const SHIP_SIZE_CLASSES = new Set([
+function shipSection(rows, sequenceId) {
+    const definitions = freezeShips(rows, sequenceId);
+    return {
+        configurations: definitions,
+        definitions: new Map(definitions.map((definition) => [definition.id, definition])),
+        sequenceId,
+    };
+}
+const SHIP_SIZE_CLASSES = /* @__PURE__ */ new Set([
     'xx-small',
     'x-small',
     'small',
@@ -116,15 +87,34 @@ function hasUniqueDefinitionIds(definitions) {
     return (new Set(definitions.map((definition) => definition.id)).size ===
         definitions.length);
 }
+function isU16(value) {
+    return isNonnegativeInteger(value) && value <= 65535;
+}
+/** A raw u64 cargo amount as an exact decimal string. */
+function isU64Decimal(value) {
+    return (typeof value === 'string' &&
+        /^(0|[1-9][0-9]{0,19})$/.test(value) &&
+        BigInt(value) <= 18446744073709551615n);
+}
+function isComponentRequirement(value) {
+    return (isRecord(value) &&
+        hasOwnKeyCount(value, 2) &&
+        isU16(value.cargoId) &&
+        isU64Decimal(value.quantityRaw));
+}
 function isShipDefinition(value) {
     return (isRecord(value) &&
-        hasOwnKeyCount(value, 5) &&
-        isNonnegativeInteger(value.id) &&
-        value.id <= 65535 &&
+        hasOwnKeyCount(value, 7) &&
+        isU16(value.id) &&
         typeof value.mint === 'string' &&
         isAddress(value.mint) &&
         typeof value.name === 'string' &&
-        SHIP_SIZE_CLASSES.has(value.sizeClass));
+        SHIP_SIZE_CLASSES.has(value.sizeClass) &&
+        Array.isArray(value.componentRequirements) &&
+        value.componentRequirements.every(isComponentRequirement) &&
+        new Set(value.componentRequirements.map((requirement) => requirement.cargoId)).size === value.componentRequirements.length &&
+        Array.isArray(value.researchRequirementTagIds) &&
+        value.researchRequirementTagIds.every(isU16));
 }
 function isCargoDefinition(value) {
     return (isRecord(value) &&
@@ -136,47 +126,82 @@ function isCargoDefinition(value) {
         typeof value.name === 'string' &&
         isNonnegativeInteger(value.storageCost));
 }
-function isCompatibleSnapshot(snapshot, game, section) {
+function isSnapshotEnvelope(snapshot, game, section, schemaVersion) {
     try {
         validateImmutableTree(snapshot);
     }
     catch {
         return false;
     }
-    if (!isRecord(snapshot) ||
-        !hasOwnKeyCount(snapshot, 5) ||
-        snapshot.schemaVersion !== (section === 'ships' ? 2 : 1) ||
-        snapshot.game !== game ||
-        snapshot.section !== section ||
-        !isNonnegativeInteger(snapshot.sequenceId) ||
-        (section === 'ships' && snapshot.sequenceId > 4294967295) ||
-        !Array.isArray(snapshot.definitions)) {
-        return false;
-    }
-    if (section === 'ships') {
-        return (snapshot.definitions.every(isShipDefinition) &&
-            hasUniqueDefinitionIds(snapshot.definitions));
-    }
-    return (snapshot.definitions.every(isCargoDefinition) &&
-        hasUniqueDefinitionIds(snapshot.definitions));
-}
-function snapshotFor(game, section, loaded) {
-    if (section === 'ships') {
-        return {
-            definitions: [...loaded.definitions.values()].map(({ id, mint, name, sizeClass, stats }) => ({
-                id,
-                mint,
-                name,
-                sizeClass,
-                stats: toJsonSafeValue(stats),
+    return (isRecord(snapshot) &&
+        hasOwnKeyCount(snapshot, 5) &&
+        snapshot.schemaVersion === schemaVersion &&
+        snapshot.game === game &&
+        snapshot.section === section &&
+        isNonnegativeInteger(snapshot.sequenceId) &&
+        Array.isArray(snapshot.definitions));
+}
+const SHIPS = {
+    section: 'ships',
+    fromGame(account, game) {
+        const ships = gameShipsRegistrySection(account, game);
+        return shipSection(ships.definitions, ships.sequenceId);
+    },
+    restore(snapshot, game) {
+        if (!isSnapshotEnvelope(snapshot, game, 'ships', 3) ||
+            snapshot.sequenceId > 4294967295 ||
+            !snapshot.definitions.every(isShipDefinition) ||
+            !hasUniqueDefinitionIds(snapshot.definitions))
+            return undefined;
+        const rows = [];
+        for (const definition of snapshot.definitions) {
+            const stats = hydrateShipStats(definition.stats);
+            if (stats === undefined)
+                return undefined;
+            rows.push({
+                ...definition,
+                stats,
+                componentRequirements: definition.componentRequirements.map(({ cargoId, quantityRaw }) => ({
+                    cargoId,
+                    quantityRaw: BigInt(quantityRaw),
+                })),
+                // Copy so freezing the restored row never freezes the store's array.
+                researchRequirementTagIds: [...definition.researchRequirementTagIds],
+            });
+        }
+        return shipSection(rows, snapshot.sequenceId);
+    },
+    toSnapshot: (game, loaded) => ({
+        definitions: [...loaded.definitions.values()].map(({ id, mint, name, sizeClass, stats, componentRequirements, researchRequirementTagIds, }) => ({
+            id,
+            mint,
+            name,
+            sizeClass,
+            stats: toJsonSafeValue(stats),
+            componentRequirements: componentRequirements.map(({ cargoId, quantityRaw }) => ({
+                cargoId,
+                quantityRaw: quantityRaw.toString(),
             })),
-            game,
-            schemaVersion: 2,
-            section,
-            sequenceId: loaded.sequenceId,
-        };
-    }
-    return {
+            researchRequirementTagIds: [...researchRequirementTagIds],
+        })),
+        game,
+        schemaVersion: 3,
+        section: 'ships',
+        sequenceId: loaded.sequenceId,
+    }),
+};
+const CARGO = {
+    section: 'cargo',
+    fromGame(account, game) {
+        const cargo = gameCargoRegistrySection(account, game);
+        return idSection(cargo.definitions, cargo.sequenceId);
+    },
+    restore: (snapshot, game) => isSnapshotEnvelope(snapshot, game, 'cargo', 1) &&
+        snapshot.definitions.every(isCargoDefinition) &&
+        hasUniqueDefinitionIds(snapshot.definitions)
+        ? idSection(snapshot.definitions, snapshot.sequenceId)
+        : undefined,
+    toSnapshot: (game, loaded) => ({
         definitions: [
             ...loaded.definitions.values(),
         ],
@@ -184,79 +209,69 @@ function snapshotFor(game, section, loaded) {
         schemaVersion: 1,
         section: 'cargo',
         sequenceId: loaded.sequenceId,
-    };
-}
-function sectionFromSnapshot(snapshot) {
-    if (snapshot.section === 'ships') {
-        const rows = [];
-        for (const definition of snapshot.definitions) {
-            const stats = hydrateShipStats(definition.stats);
-            if (stats === undefined)
-                return undefined;
-            rows.push({ ...definition, stats });
-        }
-        const definitions = freezeShips(rows, snapshot.sequenceId);
-        return {
-            configurations: definitions,
-            definitions: new Map(definitions.map((definition) => [definition.id, definition])),
-            sequenceId: snapshot.sequenceId,
-        };
-    }
-    const definitions = freezeDefinitions(snapshot.definitions);
+    }),
+};
+function persistedDriver(section, translate) {
     return {
-        definitions: new Map(definitions.map((definition) => [definition.id, definition])),
-        sequenceId: snapshot.sequenceId,
+        section,
+        fromGame: (account, game) => freezeCatalog(translate(account, game)),
+        restore(snapshot, game) {
+            const hydrated = hydrateDefinitionSectionSnapshot(snapshot, game, section);
+            return hydrated === undefined
+                ? undefined
+                : freezeCatalog(hydrated);
+        },
+        // Loaded Game projections have already passed the pinned section validator.
+        toSnapshot: (game, loaded) => encodeDefinitionSectionSnapshot(game, section, {
+            definitions: [
+                ...loaded.definitions.values(),
+            ],
+            sequenceId: loaded.sequenceId,
+        }),
     };
 }
-async function loadStoredSection(context, game, section) {
+const BUILDINGS = /* @__PURE__ */ persistedDriver('buildings', (account, game) => gameBuildingsRegistrySection(account, game));
+const CLAIM_STAKES = /* @__PURE__ */ persistedDriver('claimStakes', (account, game) => gameClaimStakesRegistrySection(account, game));
+const CRAFTING_HABS = /* @__PURE__ */ persistedDriver('craftingHabs', (account, game) => gameCraftingHabsRegistrySection(account, game));
+const HAB_BUILDINGS = /* @__PURE__ */ persistedDriver('habBuildings', (account, game) => gameHabBuildingsRegistrySection(account, game));
+const XP = {
+    section: 'xp',
+    fromGame(account, game) {
+        const [xp] = freezeDefinitions([gameXpRegistrySection(account, game)]);
+        return { definitions: new Map([[0, xp]]), sequenceId: xp.sequenceId };
+    },
+};
+const RESEARCH = {
+    section: 'research',
+    fromGame(account, game) {
+        const research = gameResearchRegistrySection(account, game);
+        return idSection(research.nodes, research.sequenceId);
+    },
+};
+async function loadStoredSection(context, game, driver) {
     assertContextActive(context);
-    if (section === 'xp' || section === 'research')
-        return undefined;
     const store = context.registrySnapshotStore;
-    if (store === undefined)
+    if (driver.restore === undefined || store === undefined)
         return undefined;
     let snapshot;
     try {
-        snapshot = await store.load(game, section);
+        snapshot = await store.load(game, driver.section);
     }
     catch {
-        throw new ProviderError(`The application registry snapshot store could not load the ${section} definitions. Repair or disable the snapshot store, then retry.`, { accountType: 'game', address: game });
-    }
-    if (isPersistedDefinitionSection(section)) {
-        const hydrated = hydrateDefinitionSectionSnapshot(snapshot, game, section);
-        return hydrated === undefined
-            ? undefined
-            : freezeCatalog(hydrated);
+        throw new ProviderError(`The application registry snapshot store could not load the ${driver.section} definitions. Repair or disable the snapshot store, then retry.`, { accountType: 'game', address: game });
     }
-    if (!isCompatibleSnapshot(snapshot, game, section))
-        return undefined;
-    return sectionFromSnapshot(snapshot);
+    return driver.restore(snapshot, game);
 }
-async function saveSection(context, game, section, loaded) {
+async function saveSection(context, game, driver, loaded) {
     assertContextActive(context);
-    if (section === 'xp' || section === 'research')
-        return;
     const store = context.registrySnapshotStore;
-    if (store === undefined)
+    if (driver.toSnapshot === undefined || store === undefined)
         return;
     try {
-        if (isPersistedDefinitionSection(section)) {
-            const definitions = loaded.definitions;
-            const snapshot = encodeDefinitionSectionSnapshot(game, section, {
-                definitions: [...definitions.values()],
-                sequenceId: loaded.sequenceId,
-            });
-            // Loaded Game projections have already passed the pinned section validator.
-            /* v8 ignore next -- the encoder also guards its typed boundary; incompatible inputs are covered in its dedicated tests. */
-            if (snapshot !== undefined)
-                await store.save(snapshot);
-        }
-        else if (section === 'ships') {
-            await store.save(snapshotFor(game, section, loaded));
-        }
-        else {
-            await store.save(snapshotFor(game, section, loaded));
-        }
+        const snapshot = driver.toSnapshot(game, loaded);
+        /* v8 ignore next -- the encoder also guards its typed boundary; incompatible inputs are covered in its dedicated tests. */
+        if (snapshot !== undefined)
+            await store.save(snapshot);
     }
     catch {
         // Snapshot persistence is a cold-start optimization. A successful Game
@@ -273,61 +288,28 @@ function invalidateSection(state, section) {
     state.revisions[section] = state.revisions[section] + 1;
     state.refresh.add(section);
 }
-async function populateFromGame(context, game, sectionsToPopulate, state) {
-    const revisions = captureSectionRevisions(state.revisions, sectionsToPopulate);
+async function populateFromGame(context, game, drivers, state) {
+    const revisions = captureSectionRevisions(state.revisions, drivers.map(({ section }) => section));
     const account = await waitForRegistry(context, context.data.readRaw(game));
     assertContextActive(context);
     if (account === undefined)
         throw new AccountNotFoundError('game', game);
-    const decoded = decodeGameRegistrySections(account, sectionsToPopulate);
-    const populated = sectionsToPopulate.map((populatedSection) => {
-        const loaded = (() => {
-            if (populatedSection === 'buildings') {
-                const buildings = sectionFromGame(decoded.buildings, 'buildings');
-                return buildings;
-            }
-            if (populatedSection === 'claimStakes') {
-                const claimStakes = sectionFromGame(decoded.claimStakes, 'claimStakes');
-                return claimStakes;
-            }
-            if (populatedSection === 'ships') {
-                const ships = sectionFromGame(decoded.ships, 'ships');
-                return ships;
-            }
-            if (populatedSection === 'cargo') {
-                const cargo = sectionFromGame(decoded.cargo, 'cargo');
-                return cargo;
-            }
-            if (populatedSection === 'craftingHabs') {
-                const craftingHabs = sectionFromGame(decoded.craftingHabs, 'craftingHabs');
-                return craftingHabs;
-            }
-            if (populatedSection === 'habBuildings') {
-                const habBuildings = sectionFromGame(decoded.habBuildings, 'habBuildings');
-                return habBuildings;
-            }
-            if (populatedSection === 'xp') {
-                const xp = sectionFromGame(decoded.xp, 'xp');
-                return xp;
-            }
-            const research = sectionFromGame(decoded.research, 'research');
-            return research;
-        })();
-        return {
-            loaded: {
-                ...loaded,
-                observation: Object.freeze({
-                    slot: account.slot,
-                    commitment: account.commitment,
-                }),
-            },
-            section: populatedSection,
-        };
-    });
+    const decoded = decodeRegistryGame(account);
+    const populated = drivers.map((driver) => ({
+        driver,
+        loaded: {
+            ...driver.fromGame(account, decoded),
+            observation: Object.freeze({
+                slot: account.slot,
+                commitment: account.commitment,
+            }),
+        },
+    }));
     assertContextActive(context);
     const saves = [];
     publishIfCurrent(state.revisions, revisions, () => {
-        for (const { loaded, section: populatedSection } of populated) {
+        for (const { driver, loaded } of populated) {
+            const populatedSection = driver.section;
             publishSection(state, populatedSection, loaded);
             const confirmingSequenceId = state.confirmingSequenceIds[populatedSection];
             if (confirmingSequenceId !== undefined) {
@@ -348,44 +330,44 @@ async function populateFromGame(context, game, sectionsToPopulate, state) {
             }
             state.refresh.delete(populatedSection);
         }
-        for (const { loaded, section } of populated)
-            saves.push(saveSection(context, game, section, loaded));
+        for (const { driver, loaded } of populated)
+            saves.push(saveSection(context, game, driver, loaded));
     });
     await waitForRegistry(context, Promise.all(saves));
 }
-async function populateSections(context, game, sections, state, fetchedTargets) {
-    const revisions = captureSectionRevisions(state.revisions, sections);
-    const stored = await waitForRegistry(context, Promise.all(sections.map(async (section) => state.refresh.has(section)
+async function populateSections(context, game, drivers, state, fetchedTargets) {
+    const revisions = captureSectionRevisions(state.revisions, drivers.map(({ section }) => section));
+    const stored = await waitForRegistry(context, Promise.all(drivers.map(async (driver) => state.refresh.has(driver.section)
         ? undefined
-        : loadStoredSection(context, game, section))));
+        : loadStoredSection(context, game, driver))));
     assertContextActive(context);
-    for (const [index, section] of sections.entries()) {
+    for (const [index, { section }] of drivers.entries()) {
         const candidate = stored[index];
         if (candidate !== undefined)
             publishIfCurrent(state.revisions, [revisions[index]], () => publishSection(state, section, candidate));
     }
-    const missing = sections.filter((section) => state.sections[section] === undefined || state.refresh.has(section));
-    if (missing.length > 0)
-        await populateFromGame(context, game, fetchedTargets.filter((section) => state.sections[section] === undefined || state.refresh.has(section)), state);
+    const isMissing = ({ section }) => state.sections[section] === undefined || state.refresh.has(section);
+    if (drivers.some(isMissing))
+        await populateFromGame(context, game, fetchedTargets.filter(isMissing), state);
 }
-async function ensureSections(context, sections, lazyPair = false) {
+/** Loads the missing `drivers`. A lookup naming a `pair` loads the whole pair
+ * from one Game read when every member is cold or every member awaits refresh. */
+async function ensureSections(context, drivers, pair) {
     const state = stateFor(context);
     for (;;) {
         assertContextActive(context);
         const game = context.game;
         if (game === undefined)
             throw new MissingGameContextError();
-        const missing = sections.filter((section) => state.sections[section] === undefined || state.refresh.has(section));
+        const missing = drivers.filter(({ section }) => state.sections[section] === undefined || state.refresh.has(section));
         if (missing.length === 0)
             return;
         let group = state.gameLoading;
         if (group === undefined) {
-            const targets = lazyPair &&
-                (missing[0] === 'ships' || missing[0] === 'cargo') &&
-                ((state.refresh.has('ships') && state.refresh.has('cargo')) ||
-                    (state.sections.ships === undefined &&
-                        state.sections.cargo === undefined))
-                ? ['ships', 'cargo']
+            const targets = pair !== undefined &&
+                (pair.every(({ section }) => state.refresh.has(section)) ||
+                    pair.every(({ section }) => state.sections[section] === undefined))
+                ? pair
                 : missing;
             const promise = Promise.resolve()
                 .then(() => populateSections(context, game, missing, state, targets))
@@ -394,7 +376,7 @@ async function ensureSections(context, sections, lazyPair = false) {
                 if (state.gameLoading?.[0] === promise)
                     delete state.gameLoading;
             });
-            group = [promise, targets];
+            group = [promise, targets.map(({ section }) => section)];
             state.gameLoading = group;
         }
         try {
@@ -402,15 +384,31 @@ async function ensureSections(context, sections, lazyPair = false) {
         }
         catch (error) {
             // Only unrelated work can fail independently of this request.
-            if (missing.some((section) => group[1].includes(section)))
+            if (missing.some(({ section }) => group[1].includes(section)))
                 throw error;
         }
     }
 }
-async function ensureSection(context, section) {
-    await ensureSections(context, [section], true);
-    return stateFor(context).sections[section];
-}
+async function ensureSection(context, driver, pair) {
+    await ensureSections(context, [driver], pair);
+    return stateFor(context).sections[driver.section];
+}
+// Only preload selects sections by name at run time, so only entries that
+// export it carry every driver.
+const SECTION_DRIVERS = {
+    ships: SHIPS,
+    cargo: CARGO,
+    buildings: BUILDINGS,
+    claimStakes: CLAIM_STAKES,
+    craftingHabs: CRAFTING_HABS,
+    habBuildings: HAB_BUILDINGS,
+    xp: XP,
+    research: RESEARCH,
+};
+// A context that resolves ships usually resolves cargo too, and D055.4 rules
+// out keeping the Game account to serve the second later, so a cold lookup of
+// either loads both from one Game read.
+const SHIPS_AND_CARGO = [SHIPS, CARGO];
 /** Warm selected definition catalogs, retaining each section's own observation.
  * Already usable sections are reused; this is not a freshness refresh.
  * @example
@@ -448,7 +446,7 @@ export async function preloadDefinitions(context, sections, options = {}) {
             targets.push(supported);
     }
     if (targets.length > 0)
-        await waitForRegistry(context, ensureSections(context, targets), options.signal);
+        await waitForRegistry(context, ensureSections(context, targets.map((section) => SECTION_DRIVERS[section])), options.signal);
     assertContextActive(context);
     const state = stateFor(context);
     const metadata = {
@@ -467,8 +465,9 @@ export async function preloadDefinitions(context, sections, options = {}) {
     deepFreeze(metadata);
     return Object.freeze(attachReadMeta(targets, metadata));
 }
-async function resolveDefinition(context, section, id, options) {
-    const loaded = await ensureSection(context, section);
+async function resolveDefinition(context, driver, id, options, pair) {
+    const { section } = driver;
+    const loaded = await ensureSection(context, driver, pair);
     const expected = options.expectedSequenceId;
     const definition = loaded.definitions.get(id);
     const state = stateFor(context);
@@ -508,7 +507,7 @@ async function resolveDefinition(context, section, id, options) {
  * ```
  */
 export function resolveShip(context, shipId, options = {}) {
-    return resolveDefinition(context, 'ships', shipId, options);
+    return resolveDefinition(context, SHIPS, shipId, options, SHIPS_AND_CARGO);
 }
 /** Lists every ship configuration in the context's loaded Game definitions section.
  *
@@ -532,7 +531,7 @@ export function resolveShip(context, shipId, options = {}) {
  * ```
  */
 export async function listShipConfigurations(context) {
-    const loaded = (await ensureSection(context, 'ships'));
+    const loaded = (await ensureSection(context, SHIPS, SHIPS_AND_CARGO));
     return loaded.configurations;
 }
 /** Lists current ship configurations associated with a mint in this context's Game.
@@ -559,7 +558,7 @@ export async function listShipConfigurations(context) {
  * ```
  */
 export async function listShipConfigurationsByMint(context, mint) {
-    const loaded = (await ensureSection(context, 'ships'));
+    const loaded = (await ensureSection(context, SHIPS, SHIPS_AND_CARGO));
     if (loaded.mintIndex === undefined) {
         const groups = new Map();
         for (const ship of loaded.configurations) {
@@ -586,7 +585,7 @@ export async function listShipConfigurationsByMint(context, mint) {
  * ```
  */
 export function resolveCargo(context, cargoId, options = {}) {
-    return resolveDefinition(context, 'cargo', cargoId, options);
+    return resolveDefinition(context, CARGO, cargoId, options, SHIPS_AND_CARGO);
 }
 /** Resolves one Crafting Hab definition with sequence-aware invalidation.
  * @example
@@ -596,7 +595,7 @@ export function resolveCargo(context, cargoId, options = {}) {
  * ```
  */
 export function resolveCraftingHabDefinition(context, definitionId, options = {}) {
-    return resolveDefinition(context, 'craftingHabs', definitionId, options);
+    return resolveDefinition(context, CRAFTING_HABS, definitionId, options);
 }
 /** Resolves one Crafting Hab building definition with sequence-aware invalidation.
  * @example
@@ -606,15 +605,15 @@ export function resolveCraftingHabDefinition(context, definitionId, options = {}
  * ```
  */
 export function resolveHabBuildingDefinition(context, buildingId, options = {}) {
-    return resolveDefinition(context, 'habBuildings', buildingId, options);
+    return resolveDefinition(context, HAB_BUILDINGS, buildingId, options);
 }
 /** Resolves the Game XP rules matching one Character XP sequence. */
 export function resolveXpDefinitions(context, options = {}) {
-    return resolveDefinition(context, 'xp', 0, options);
+    return resolveDefinition(context, XP, 0, options);
 }
 /** Lists the independent immutable Game research catalog. */
 export async function listResearchDefinitions(context) {
-    const loaded = (await ensureSection(context, 'research'));
+    const loaded = (await ensureSection(context, RESEARCH));
     return deepFreeze({
         definitions: [...loaded.definitions.values()],
         sequenceId: loaded.sequenceId,
@@ -623,28 +622,28 @@ export async function listResearchDefinitions(context) {
 export { RegistryOutOfSyncError } from '../client/errors.js';
 /** Internal Claim Stake lookup using the shared section lifecycle. */
 export function resolveClaimStakeDefinition(context, id) {
-    return resolveDefinition(context, 'claimStakes', id, {});
+    return resolveDefinition(context, CLAIM_STAKES, id, {});
 }
 /** Internal canonical Claim Stake catalog. */
 export async function listClaimStakeDefinitions(context) {
-    return (await ensureSection(context, 'claimStakes')).catalog;
+    return (await ensureSection(context, CLAIM_STAKES)).catalog;
 }
 /** Internal canonical Crafting Hab container catalog. */
 export async function listCraftingHabDefinitions(context) {
-    return (await ensureSection(context, 'craftingHabs')).catalog;
+    return (await ensureSection(context, CRAFTING_HABS)).catalog;
 }
 /** Internal Building definition lookup using the shared section lifecycle. */
 export function resolveClaimStakeBuildingDefinition(context, id) {
-    return resolveDefinition(context, 'buildings', id, {});
+    return resolveDefinition(context, BUILDINGS, id, {});
 }
 /** Internal canonical Claim Stake building catalog. */
 export async function listClaimStakeBuildingDefinitions(context) {
-    return (await ensureSection(context, 'buildings'))
+    return (await ensureSection(context, BUILDINGS))
         .catalog;
 }
 /** Internal canonical Hab building catalog. */
 export async function listHabBuildingDefinitions(context) {
-    return (await ensureSection(context, 'habBuildings')).catalog;
+    return (await ensureSection(context, HAB_BUILDINGS)).catalog;
 }
 /** Lists all cargo definitions from the context's retained Game section.
  *
@@ -662,7 +661,7 @@ export async function listHabBuildingDefinitions(context) {
  * ```
  */
 export async function listCargoDefinitions(context) {
-    const loaded = (await ensureSection(context, 'cargo'));
+    const loaded = (await ensureSection(context, CARGO, SHIPS_AND_CARGO));
     return (loaded.catalog ??= Object.freeze([...loaded.definitions.values()]));
 }
 //# sourceMappingURL=index.js.map