@openmrs/esm-config 10.0.1-pre.5263 → 10.0.1-pre.5299

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
-[0] Successfully compiled: 8 files with swc (144.02ms)
+[0] Successfully compiled: 8 files with swc (272.53ms)
 [0] swc --strip-leading-paths src -d dist exited with code 0
 [1] tsc --project tsconfig.build.json exited with code 0

package/dist/module-config/module-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-config.d.ts","sourceRoot":"","sources":["../../src/module-config/module-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAuB,MAAM,UAAU,CAAC;AA+KxF;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAS1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,MAAM,QAKhE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,QAKpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,QAK7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAetF;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,SAAa,QAK9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAgBjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAwCxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAKvG;AA2eD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,QAUjD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,SAIhC"}
+{"version":3,"file":"module-config.d.ts","sourceRoot":"","sources":["../../src/module-config/module-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAuB,MAAM,UAAU,CAAC;AAySxF;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAS1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,MAAM,QAKhE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,QAKpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,QAK7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAetF;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,SAAa,QAK9D;AAiCD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAMjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAoBxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAKvG;AAomBD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,QAUjD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,SAUhC"}

package/dist/module-config/module-config.js

@@ -2,7 +2,7 @@
 import { Type } from "../types.js";
 import { isArray, isBoolean, isUuid, isNumber, isObject, isString } from "../validators/type-validators.js";
 import { validator } from "../validators/validator.js";
-import { configExtensionStore, configInternalStore, getConfigStore, getExtensionConfig, getExtensionSlotsConfigStore, getExtensionsConfigStore, implementerToolsConfigStore, temporaryConfigStore } from "./state.js";
+import { configExtensionStore, configInternalStore, getConfigStore, getExtensionConfig, getExtensionSlotsConfigStore, getExtensionsConfigStore, clearConfigDerivationError, implementerToolsConfigStore, invalidateImplementerToolsConfig, recordConfigDerivationError, setImplementerToolsConfigRecomputer, temporaryConfigStore } from "./state.js";
 /**
  * Deep merge two objects, with right-side values taking precedence.
  * Arrays are replaced entirely (not merged by index), matching the
@@ -43,21 +43,33 @@ const configSubscriptions = [];
     const tempConfigState = temporaryConfigStore.getState();
     const extensionState = configExtensionStore.getState();
     computeModuleConfig(configState, tempConfigState);
-    computeImplementerToolsConfig(configState, tempConfigState);
     computeExtensionSlotConfigs(configState, tempConfigState);
     computeExtensionConfigs(configState, extensionState, tempConfigState);
+    // Last, because a failure here must not skip the outputs above. Only kept current while the
+    // implementer tools are watching it; otherwise derived on read.
+    invalidateImplementerToolsConfig();
 }
 function setupConfigSubscriptions() {
+    // Registered here rather than at module load so that `resetConfigSystem` restores it.
+    setImplementerToolsConfigRecomputer(()=>computeImplementerToolsConfig(configInternalStore.getState(), temporaryConfigStore.getState()));
     // Initial computation
     recomputeAllConfigs();
     // Subscribe to all input stores with a single handler
     // This ensures we only recompute once even if multiple stores change simultaneously
-    configSubscriptions.push(configInternalStore.subscribe(recomputeAllConfigs));
-    configSubscriptions.push(temporaryConfigStore.subscribe(recomputeAllConfigs));
-    configSubscriptions.push(configExtensionStore.subscribe(recomputeAllConfigs));
+    configSubscriptions.push(configInternalStore.subscribe(recomputeAllConfigsSafely), temporaryConfigStore.subscribe(recomputeAllConfigsSafely), configExtensionStore.subscribe(recomputeAllConfigsSafely));
+}
+/** Ensure that we do not throw during a store subscription */ function recomputeAllConfigsSafely() {
+    clearConfigDerivationError();
+    try {
+        recomputeAllConfigs();
+    } catch (e) {
+        recordConfigDerivationError(e);
+        console.error('Failed to recompute the configuration', e);
+    }
 }
 // Set up subscriptions at module load time
 setupConfigSubscriptions();
+const moduleConfigCache = new Map();
 function computeModuleConfig(state, tempState) {
     for (let moduleName of Object.keys(state.schemas)){
         // At this point the schema could be either just the implicit schema or the actually
@@ -67,44 +79,62 @@ function computeModuleConfig(state, tempState) {
         // available, which as of this writing blocks the schema definition from occurring
         // for modules loaded based on their extensions.
         const moduleStore = getConfigStore(moduleName);
+        const schema = state.schemas[moduleName];
+        const moduleLoaded = Boolean(state.moduleLoaded[moduleName]);
+        const cached = moduleConfigCache.get(moduleName);
         let newState;
-        if (state.moduleLoaded[moduleName]) {
-            const config = getConfigForModule(moduleName, state, tempState);
-            newState = {
-                translationOverridesLoaded: true,
-                loaded: true,
-                config
-            };
+        if (cached && cached.schema === schema && cached.moduleLoaded === moduleLoaded && cached.providedConfigs === state.providedConfigs && cached.temporaryConfig === tempState.config) {
+            newState = cached.state;
         } else {
-            const config = getConfigForModuleImplicitSchema(moduleName, state, tempState);
+            const config = moduleLoaded ? getConfigForModule(moduleName, state, tempState) : getConfigForModuleImplicitSchema(moduleName, state, tempState);
             newState = {
                 translationOverridesLoaded: true,
-                loaded: false,
+                loaded: moduleLoaded,
                 config
             };
+            moduleConfigCache.set(moduleName, {
+                schema,
+                moduleLoaded,
+                providedConfigs: state.providedConfigs,
+                temporaryConfig: tempState.config,
+                state: newState
+            });
+        }
+        // Writing unconditionally would hand every `useConfig` consumer in the application a new
+        // object — and a re-render — whenever any module or extension anywhere is loaded.
+        const oldState = moduleStore.getState();
+        if (oldState.loaded !== newState.loaded || oldState.translationOverridesLoaded !== newState.translationOverridesLoaded || !isEqual(oldState.config, newState.config)) {
+            moduleStore.setState(newState);
         }
-        moduleStore.setState(newState);
     }
 }
 function computeExtensionSlotConfigs(state, tempState) {
     const slotConfigs = getExtensionSlotConfigs(state, tempState);
-    const newSlotStoreEntries = Object.fromEntries(Object.entries(slotConfigs).map(([slotName, config])=>[
-            slotName,
-            {
+    const slotStore = getExtensionSlotsConfigStore();
+    const oldSlots = slotStore.getState().slots;
+    const slots = {};
+    let changed = false;
+    for (const [slotName, config] of Object.entries(slotConfigs)){
+        const previous = oldSlots[slotName];
+        // Entries keep their identity when the configuration behind them hasn't changed, so that
+        // changing one slot's configuration doesn't invalidate every other configured slot.
+        if (previous?.loaded && isEqual(previous.config, config)) {
+            slots[slotName] = previous;
+        } else {
+            slots[slotName] = {
                 loaded: true,
                 config
-            }
-        ]));
-    const slotStore = getExtensionSlotsConfigStore();
-    const oldState = slotStore.getState();
-    const newState = {
-        slots: {
-            ...oldState.slots,
-            ...newSlotStoreEntries
+            };
+            changed = true;
         }
-    };
-    if (!isEqual(oldState.slots, newState.slots)) {
-        slotStore.setState(newState);
+    }
+    // Built from scratch rather than merged over the previous state: a slot whose configuration
+    // has been removed — clearing the temporary config, say — has to lose its entry, or the old
+    // configuration stays in force until the page is reloaded.
+    if (changed || Object.keys(oldSlots).length !== Object.keys(slots).length) {
+        slotStore.setState({
+            slots
+        });
     }
 }
 function computeImplementerToolsConfig(state, tempConfigState) {
@@ -119,27 +149,49 @@ function computeImplementerToolsConfig(state, tempConfigState) {
     }
 }
 function computeExtensionConfigs(configState, extensionState, tempConfigState) {
+    const extensionsConfigStore = getExtensionsConfigStore();
+    const oldConfigs = extensionsConfigStore.getState().configs;
     const configs = {};
+    let changed = false;
+    let entryCount = 0;
     // We assume that the module schema has already been defined, since the extension
     // it contains is mounted.
     for (let extension of extensionState.mountedExtensions){
         const config = computeExtensionConfig(extension.slotModuleName, extension.extensionModuleName, extension.slotName, extension.extensionId, configState, tempConfigState);
-        if (!configs[extension.slotName]) {
-            configs[extension.slotName] = {};
-        }
-        configs[extension.slotName][extension.extensionId] = {
+        const previous = oldConfigs[extension.slotName]?.[extension.extensionId];
+        // Entries keep their identity when the configuration behind them hasn't changed, so that
+        // mounting one extension doesn't hand every other mounted extension a new config object.
+        const entry = previous?.loaded && isEqual(previous.config, config) ? previous : {
             config,
             loaded: true
         };
+        if (entry !== previous) {
+            changed = true;
+        }
+        if (!configs[extension.slotName]) {
+            configs[extension.slotName] = {};
+        }
+        configs[extension.slotName][extension.extensionId] = entry;
+        entryCount++;
+    }
+    // Slots keep their identity too when none of their entries changed. Subscribers compare these
+    // per-slot objects to work out which slots to re-derive, so handing out a fresh one for every
+    // slot on every write would mark every slot with a mounted extension dirty.
+    for (const [slotName, slotConfigs] of Object.entries(configs)){
+        const previousSlot = oldConfigs[slotName];
+        if (previousSlot && Object.keys(previousSlot).length === Object.keys(slotConfigs).length && Object.entries(slotConfigs).every(([extensionId, entry])=>previousSlot[extensionId] === entry)) {
+            configs[slotName] = previousSlot;
+        }
     }
-    const extensionsConfigStore = getExtensionsConfigStore();
-    const oldState = extensionsConfigStore.getState();
-    const newState = {
-        configs
-    };
-    // Use deep equality to only update if configs actually changed
-    if (!isEqual(oldState.configs, newState.configs)) {
-        extensionsConfigStore.setState(newState);
+    if (!changed) {
+        // Nothing was added or altered, but an extension may have unmounted, which only shows up as a
+        // missing entry.
+        changed = Object.keys(oldConfigs).length !== Object.keys(configs).length || Object.values(oldConfigs).reduce((total, slot)=>total + Object.keys(slot).length, 0) !== entryCount;
+    }
+    if (changed) {
+        extensionsConfigStore.setState({
+            configs
+        });
     }
 }
 /*
@@ -273,6 +325,28 @@ function computeExtensionConfigs(configState, extensionState, tempConfigState) {
             ]
         }));
 }
+/**
+ * Resolves with `select(state)` as soon as the store's state satisfies `ready`, leaving no
+ * subscription behind: nothing subscribes at all when the store is already ready. That matters
+ * because `getConfig` runs on every HTTP request, and a subscription that outlives its promise
+ * both retains its closure forever and slows down every later write to that store.
+ */ function whenStoreReady(store, ready, select) {
+    return new Promise((resolve)=>{
+        let unsubscribe;
+        let resolved = false;
+        function update(state) {
+            if (!resolved && ready(state)) {
+                resolved = true;
+                resolve(select(state));
+                unsubscribe?.();
+            }
+        }
+        update(store.getState());
+        if (!resolved) {
+            unsubscribe = store.subscribe(update);
+        }
+    });
+}
 /**
  * A promise-based way to access the config as soon as it is fully loaded.
  * If it is already loaded, resolves the config in its present state.
@@ -282,23 +356,10 @@ function computeExtensionConfigs(configState, extensionState, tempConfigState) {
  *
  * @param moduleName The name of the module for which to look up the config
  */ export function getConfig(moduleName) {
-    return new Promise((resolve)=>{
-        const store = getConfigStore(moduleName);
-        function update(state) {
-            if (state.loaded && state.config) {
-                const config = lodashOmit(state.config, [
-                    'Display conditions',
-                    'Translation overrides'
-                ]);
-                resolve(config);
-                if (unsubscribe) {
-                    unsubscribe();
-                }
-            }
-        }
-        update(store.getState());
-        const unsubscribe = store.subscribe(update);
-    });
+    return whenStoreReady(getConfigStore(moduleName), (state)=>Boolean(state.loaded && state.config), (state)=>lodashOmit(state.config, [
+            'Display conditions',
+            'Translation overrides'
+        ]));
 }
 /**
  * Retrieves translation overrides for an extension, optionally scoped to a specific
@@ -314,36 +375,10 @@ function computeExtensionConfigs(configState, extensionState, tempConfigState) {
  * @internal
  */ export function getTranslationOverrides(moduleName, slotName, extensionId) {
     const promises = [
-        new Promise((resolve)=>{
-            const configStore = getConfigStore(moduleName);
-            function update(state) {
-                if (state.translationOverridesLoaded && state.config) {
-                    const translationOverrides = state.config['Translation overrides'] ?? {};
-                    resolve(translationOverrides);
-                    if (unsubscribe) {
-                        unsubscribe();
-                    }
-                }
-            }
-            update(configStore.getState());
-            const unsubscribe = configStore.subscribe(update);
-        })
+        whenStoreReady(getConfigStore(moduleName), (state)=>Boolean(state.translationOverridesLoaded && state.config), (state)=>state.config['Translation overrides'] ?? {})
     ];
     if (slotName && extensionId) {
-        promises.push(new Promise((resolve)=>{
-            const configStore = getExtensionConfig(slotName, extensionId);
-            function update(state) {
-                if (state.loaded && state.config) {
-                    const translationOverrides = state.config['Translation overrides'] ?? {};
-                    resolve(translationOverrides);
-                    if (unsubscribe) {
-                        unsubscribe();
-                    }
-                }
-            }
-            update(configStore.getState());
-            const unsubscribe = configStore.subscribe(update);
-        }));
+        promises.push(whenStoreReady(getExtensionConfig(slotName, extensionId), (state)=>Boolean(state.loaded && state.config), (state)=>state.config['Translation overrides'] ?? {}));
     }
     return Promise.all(promises);
 }
@@ -362,10 +397,8 @@ function computeExtensionConfigs(configState, extensionState, tempConfigState) {
     runAllValidatorsInConfigTree(schema, config, keyPathContext);
     return config;
 }
-/*
- * Helper functions
- *
- */ /**
+const extensionConfigCache = new Map();
+/**
  * Returns the configuration for an extension. This configuration is specific
  * to the slot in which it is mounted, and its ID within that slot.
  *
@@ -380,6 +413,17 @@ function computeExtensionConfigs(configState, extensionState, tempConfigState) {
  */ function computeExtensionConfig(slotModuleName, extensionModuleName, slotName, extensionId, configState, tempConfigState) {
     const extensionName = getExtensionNameFromId(extensionId);
     const extensionConfigSchema = configState.schemas[extensionName];
+    // JSON string of these elements should be unique-per-extension
+    const cacheKey = JSON.stringify([
+        slotName,
+        extensionId,
+        slotModuleName,
+        extensionModuleName
+    ]);
+    const cached = extensionConfigCache.get(cacheKey);
+    if (cached && cached.extensionSchema === extensionConfigSchema && cached.extensionModuleSchema === configState.schemas[extensionModuleName] && cached.providedConfigs === configState.providedConfigs && cached.temporaryConfig === tempConfigState.config) {
+        return cached.config;
+    }
     const nameOfSchemaSource = extensionConfigSchema ? extensionName : extensionModuleName;
     const providedConfigs = getProvidedConfigs(configState, tempConfigState);
     const slotModuleConfig = mergeConfigsFor(slotModuleName, providedConfigs);
@@ -394,10 +438,18 @@ function computeExtensionConfigs(configState, extensionState, tempConfigState) {
     const config = setDefaults(schema, combinedConfig);
     runAllValidatorsInConfigTree(schema, config, nameOfSchemaSource);
     delete config.extensionSlots;
+    extensionConfigCache.set(cacheKey, {
+        extensionSchema: extensionConfigSchema,
+        extensionModuleSchema: configState.schemas[extensionModuleName],
+        providedConfigs: configState.providedConfigs,
+        temporaryConfig: tempConfigState.config,
+        config
+    });
     return config;
 }
+const implementerToolsModuleCache = new Map();
 function getImplementerToolsConfig(configState, tempConfigState) {
-    let result = getSchemaWithValuesAndSources(cloneDeep(configState.schemas));
+    const annotatedSchemas = getAllSchemasWithValuesAndSources(configState.schemas);
     const configsAndSources = [
         ...configState.providedConfigs.map((c)=>[
                 c.config,
@@ -408,11 +460,62 @@ function getImplementerToolsConfig(configState, tempConfigState) {
             'temporary config'
         ]
     ];
-    for (let [config, source] of configsAndSources){
-        result = mergeConfigs([
-            result,
-            createValuesAndSourcesTree(config, source)
-        ]);
+    // A module can be configured without having declared a schema, so the module list is the union
+    // of both rather than just the schemas.
+    const moduleNames = new Set(Object.keys(annotatedSchemas));
+    for (const [config] of configsAndSources){
+        for (const moduleName of Object.keys(config)){
+            moduleNames.add(moduleName);
+        }
+    }
+    const result = {};
+    for (const moduleName of moduleNames){
+        const annotatedSchema = annotatedSchemas[moduleName];
+        const configSlices = configsAndSources.map(([config])=>config[moduleName]);
+        const sources = configsAndSources.map(([, source])=>source);
+        const cached = implementerToolsModuleCache.get(moduleName);
+        if (cached && cached.annotatedSchema === annotatedSchema && cached.configSlices.length === configSlices.length && cached.configSlices.every((slice, i)=>slice === configSlices[i]) && cached.sources.every((source, i)=>source === sources[i])) {
+            result[moduleName] = cached.result;
+            continue;
+        }
+        let merged = annotatedSchema ?? {};
+        configsAndSources.forEach(([, source], i)=>{
+            const slice = configSlices[i];
+            if (slice !== undefined) {
+                merged = mergeDeepReplace(merged, createValuesAndSourcesTree(slice, source));
+            }
+        });
+        implementerToolsModuleCache.set(moduleName, {
+            annotatedSchema,
+            configSlices,
+            sources,
+            result: merged
+        });
+        result[moduleName] = merged;
+    }
+    return result;
+}
+/**
+ * Caching per module is what stops the walk being quadratic: defining one module's schema
+ * recomputes every module.
+ *
+ * A module with no configuration of its own is published straight from this cache, so nothing may
+ * mutate a tree it reads out of the implementer tools config — it is the cache entry.
+ */ const schemaValuesAndSourcesCache = new Map();
+function getAllSchemasWithValuesAndSources(schemas) {
+    const result = {};
+    for (const [moduleName, schema] of Object.entries(schemas)){
+        const cached = schemaValuesAndSourcesCache.get(moduleName);
+        if (cached && cached.schema === schema) {
+            result[moduleName] = cached.annotated;
+        } else {
+            const annotated = getSchemaWithValuesAndSources(cloneDeep(schema));
+            schemaValuesAndSourcesCache.set(moduleName, {
+                schema,
+                annotated
+            });
+            result[moduleName] = annotated;
+        }
     }
     return result;
 }
@@ -809,6 +912,12 @@ function logError(keyPath, message) {
  */ export function resetConfigSystem() {
     configSubscriptions.forEach((unsubscribe)=>unsubscribe());
     configSubscriptions.length = 0;
+    // Cached configs are keyed on input identity, so a test that reuses the same schema or config
+    // objects across cases would otherwise be served the previous case's result.
+    moduleConfigCache.clear();
+    extensionConfigCache.clear();
+    schemaValuesAndSourcesCache.clear();
+    implementerToolsModuleCache.clear();
     setupConfigSubscriptions();
 }
 /**

package/dist/module-config/state.d.ts

@@ -108,8 +108,19 @@ export interface ExtensionsConfigStore {
  * @internal
  */
 export declare function getExtensionsConfigStore(): StoreApi<ExtensionsConfigStore>;
-/** @internal */
-export declare function getExtensionConfig(slotName: string, extensionId: string): StoreApi<Omit<ConfigStore, 'translationOverridesLoaded'>>;
+/**
+ * The read-only part of a store's API.
+ * @internal
+ */
+export type ReadableStore<T> = Pick<StoreApi<T>, 'getInitialState' | 'getState' | 'subscribe'>;
+/**
+ * A read-only view of one extension instance's config within a slot. Read-only because these
+ * configs are derived from the config system's inputs, so a write here would be overwritten by the
+ * next recomputation; provide a config or set a temporary one instead.
+ *
+ * @internal
+ */
+export declare function getExtensionConfig(slotName: string, extensionId: string): ReadableStore<Omit<ConfigStore, 'translationOverridesLoaded'>>;
 /** @internal */
 export declare function getExtensionConfigFromStore(state: ExtensionsConfigStore, slotName: string, extensionId: string): ConfigStore;
 /** @internal */
@@ -120,7 +131,40 @@ export declare function getExtensionConfigFromExtensionSlotStore(state: Extensio
  */
 export interface ImplementerToolsConfigStore {
     config: Config;
+    /**
+     * Set when the last attempt to derive `config` threw, in which case `config` is whatever was
+     * last derived successfully — on a first failure, nothing at all. Cleared by a later success.
+     */
+    derivationError?: string;
 }
-/** @internal */
+/**
+ * Registers how to derive the implementer tools config; the store decides whether to.
+ * @internal
+ */
+export declare function setImplementerToolsConfigRecomputer(recompute: () => void): void;
+/**
+ * Marks the implementer tools config stale, deriving it again only if something is watching.
+ * @internal
+ */
+export declare function invalidateImplementerToolsConfig(): void;
+/**
+ * Records that configuration could not be rebuilt so that the user can be informed
+ *
+ * @internal
+ */
+export declare function recordConfigDerivationError(error: unknown): void;
+/**
+ * Cleared at the start of a derivation pass rather than the end of a successful one, so that a
+ * failure recorded partway through the pass is not wiped by the pass completing.
+ *
+ * @internal
+ */
+export declare function clearConfigDerivationError(): void;
+/**
+ * Published rather than the store it wraps, so that a lookup by name can't hand out the one that
+ * skips the derivation and always reads empty.
+ *
+ * @internal
+ */
 export declare const implementerToolsConfigStore: StoreApi<ImplementerToolsConfigStore>;
 //# sourceMappingURL=state.d.ts.map

package/dist/module-config/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/module-config/state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/module-config/state.ts"],"names":[],"mappings":"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"}