@fgv/ts-res 5.0.1-8 → 5.0.1

package/dist/packlets/runtime/conditionSetResolutionResult.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { captureResult } from '@fgv/ts-utils';
+/**
+ * Represents the result of resolving a condition set.
+ * Contains either a failure indicator or a list of condition priority/score tuples sorted by priority then score.
+ * @public
+ */
+export class ConditionSetResolutionResult {
+    /**
+     * Constructor for a {@link Runtime.ConditionSetResolutionResult | ConditionSetResolutionResult}.
+     * @param success - Whether the condition set resolution was successful.
+     * @param matches - Array of condition match results, if successful.
+     */
+    constructor(matchType, matches) {
+        this.matchType = matchType;
+        this.matches = [...matches];
+    }
+    /**
+     * Creates a new condition set resolution result.
+     * @param matchType - The type of match.
+     * @param matches - Array of condition match results.
+     * @returns A new {@link Runtime.ConditionSetResolutionResult | ConditionSetResolutionResult}.
+     * @public
+     */
+    static create(matchType, matches) {
+        return captureResult(() => new ConditionSetResolutionResult(matchType, matches));
+    }
+    /**
+     * Compares two condition set resolution results for sorting purposes.
+     * The priority of a condition set result cannot be boiled down to a single number -
+     * we have to examine each condition result in turn.
+     *
+     * Comparison logic:
+     * - If priority differs, return the higher priority
+     * - If priority matches but score is different, return the higher score
+     * - If priority and score both match, proceed to the next condition
+     * - Failed results are considered lower priority than successful results
+     *
+     * @param a - The first condition set resolution result to compare.
+     * @param b - The second condition set resolution result to compare.
+     * @returns A negative number if a should come before b, a positive number if a should
+     * come after b, or zero if they are equivalent.
+     * @public
+     */
+    static compare(a, b) {
+        // Failed results are always lower priority than default match which are lower than match
+        if (a.matchType === 'match') {
+            if (b.matchType !== 'match')
+                return -1;
+        }
+        else if (a.matchType === 'matchAsDefault') {
+            /* c8 ignore next 5 - edge case comparison for matchAsDefault rarely hit in practice */
+            if (b.matchType === 'match') {
+                return 1;
+            }
+            else if (b.matchType === 'noMatch') {
+                return -1;
+            }
+        }
+        else {
+            /* c8 ignore next 7 - edge case comparison for noMatch rarely hit in practice */
+            // a.matchType === 'noMatch'
+            if (b.matchType === 'noMatch') {
+                return 0;
+            }
+            else {
+                return 1; // noMatch comes after any other match type
+            }
+        }
+        // Both are successful with the same match type - compare condition by condition
+        const minLength = Math.min(a.matches.length, b.matches.length);
+        for (let i = 0; i < minLength; i++) {
+            const matchA = a.matches[i];
+            const matchB = b.matches[i];
+            // Compare priority first
+            const priorityDiff = matchB.priority - matchA.priority;
+            if (priorityDiff !== 0) {
+                return priorityDiff;
+            }
+            // If priority matches, compare score
+            const scoreDiff = matchB.score - matchA.score;
+            /* c8 ignore next 3 - edge case: score comparison when priorities are equal */
+            if (scoreDiff !== 0) {
+                return scoreDiff;
+            }
+            // If both priority and score match, continue to next condition
+        }
+        // If all compared conditions are equal, the one with more conditions wins
+        return b.matches.length - a.matches.length;
+    }
+    /**
+     * Gets the highest priority among all condition matches.
+     * @returns The highest priority, or 0 if no matches.
+     * @public
+     */
+    get maxPriority() {
+        if (this.matchType === 'noMatch' || this.matches.length === 0) {
+            return 0;
+        }
+        return Math.max(...this.matches.map((m) => m.priority));
+    }
+    /**
+     * Gets the total score by summing all condition match scores.
+     * @returns The total score, or 0 if no matches.
+     * @public
+     */
+    get totalScore() {
+        if (this.matchType === 'noMatch' || this.matches.length === 0) {
+            return 0;
+        }
+        return this.matches.reduce((sum, match) => sum + match.score, 0);
+    }
+}
+//# sourceMappingURL=conditionSetResolutionResult.js.map

package/dist/packlets/runtime/context/contextQualifierProvider.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Abstract base class for implementing context qualifier providers.
+ * Provides common functionality and enforces the contract for derived classes.
+ * @public
+ */
+export class ContextQualifierProvider {
+}
+//# sourceMappingURL=contextQualifierProvider.js.map

package/dist/packlets/runtime/context/contextQualifierProviderValidator.js

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { captureResult, Converters } from '@fgv/ts-utils';
+import { Convert as CommonConverters } from '../../common';
+/**
+ * Base implementation class containing shared validation logic for both read-only and mutable validators.
+ * @internal
+ */
+class BaseContextQualifierProviderValidator {
+    /**
+     * The readonly qualifier collector that defines and validates the qualifiers for this context.
+     */
+    get qualifiers() {
+        return this.provider.qualifiers;
+    }
+    /**
+     * Gets a qualifier value by its string name, converting to strongly-typed QualifierName.
+     * @param name - The string name to convert and look up.
+     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    get(name) {
+        return CommonConverters.qualifierName.convert(name).onSuccess((qualifierName) => {
+            return this.provider.get(qualifierName);
+        });
+    }
+    /**
+     * Gets a qualifier value by its number index, converting to strongly-typed QualifierIndex.
+     * @param index - The number index to convert and look up.
+     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    getByIndex(index) {
+        return CommonConverters.qualifierIndex.convert(index).onSuccess((qualifierIndex) => {
+            return this.provider.get(qualifierIndex);
+        });
+    }
+    /**
+     * Gets a validated qualifier context value by its string name.
+     * @param name - The string name to convert and look up.
+     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found, invalid, or an error occurs.
+     */
+    getValidated(name) {
+        return CommonConverters.qualifierName.convert(name).onSuccess((qualifierName) => {
+            return this.provider.getValidated(qualifierName);
+        });
+    }
+    /**
+     * Gets a validated qualifier context value by its number index.
+     * @param index - The number index to convert and look up.
+     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found, invalid, or an error occurs.
+     */
+    getValidatedByIndex(index) {
+        return CommonConverters.qualifierIndex.convert(index).onSuccess((qualifierIndex) => {
+            return this.provider.getValidated(qualifierIndex);
+        });
+    }
+    /**
+     * Checks if a qualifier value exists with the given string name.
+     * @param name - The string name to convert and check.
+     * @returns `Success` with `true` if the qualifier value exists, `false` if it doesn't,
+     * or `Failure` with an error message if an error occurs during the check.
+     */
+    has(name) {
+        return CommonConverters.qualifierName.convert(name).onSuccess((qualifierName) => {
+            return this.provider.has(qualifierName);
+        });
+    }
+}
+/**
+ * A validator for read-only context qualifier providers that accepts string inputs
+ * and converts them to strongly-typed values before calling the wrapped provider.
+ * Only provides read operations for compile-time type safety.
+ * @public
+ */
+export class ReadOnlyContextQualifierProviderValidator extends BaseContextQualifierProviderValidator {
+    /**
+     * Constructs a new {@link Runtime.Context.ReadOnlyContextQualifierProviderValidator | ReadOnlyContextQualifierProviderValidator}.
+     * @param params - Required parameters for constructing the validator.
+     */
+    constructor(params) {
+        super();
+        this.provider = params.provider;
+    }
+}
+/**
+ * A validator for mutable context qualifier providers that accepts string inputs
+ * and converts them to strongly-typed values before calling the wrapped provider.
+ * Provides both read and mutation operations.
+ * @public
+ */
+export class MutableContextQualifierProviderValidator extends BaseContextQualifierProviderValidator {
+    /**
+     * Constructs a new {@link Runtime.Context.MutableContextQualifierProviderValidator | MutableContextQualifierProviderValidator}.
+     * @param params - Required parameters for constructing the validator.
+     */
+    constructor(params) {
+        super();
+        this.provider = params.provider;
+    }
+    /**
+     * Sets a qualifier value using string inputs, converting to strongly-typed values.
+     * @param name - The string name to convert.
+     * @param value - The string value to convert.
+     * @returns `Success` with the set {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if an error occurs.
+     */
+    set(name, value) {
+        return CommonConverters.qualifierName.convert(name).onSuccess((qualifierName) => this.provider.qualifiers.validating.get(name).asResult.onSuccess((qualifier) => Converters.string.convert(value).onSuccess((stringValue) => qualifier.validateContextValue(stringValue).onSuccess((qualifierValue) => {
+            return captureResult(() => this.provider.set(qualifierName, qualifierValue)).onSuccess((result) => result);
+        }))));
+    }
+    /**
+     * Removes a qualifier value using string input, converting to strongly-typed QualifierName.
+     * @param name - The string name to convert.
+     * @returns `Success` with the removed {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if an error occurs.
+     */
+    remove(name) {
+        return CommonConverters.qualifierName.convert(name).onSuccess((qualifierName) => {
+            return captureResult(() => this.provider.remove(qualifierName)).onSuccess((result) => result);
+        });
+    }
+}
+//# sourceMappingURL=contextQualifierProviderValidator.js.map

package/dist/packlets/runtime/context/index.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export * from './contextQualifierProvider';
+export * from './contextQualifierProviderValidator';
+export * from './simpleContextQualifierProvider';
+export * from './validatingSimpleContextQualifierProvider';
+//# sourceMappingURL=index.js.map

package/dist/packlets/runtime/context/simpleContextQualifierProvider.js

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { ResultMap, captureResult, succeed, succeedWithDetail, Converters } from '@fgv/ts-utils';
+import { Validate, Convert as CommonConverters } from '../../common';
+import { Qualifier } from '../../qualifiers';
+import { ContextQualifierProvider } from './contextQualifierProvider';
+/**
+ * Simple concrete implementation of {@link Runtime.Context.IContextQualifierProvider | IContextQualifierProvider}
+ * using a `ResultMap` for qualifier value storage.
+ * @public
+ */
+export class SimpleContextQualifierProvider extends ContextQualifierProvider {
+    /**
+     * Constructor for a {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} object.
+     * @param params - {@link Runtime.ISimpleContextQualifierProviderCreateParams | Parameters} used to create the provider.
+     */
+    constructor(params) {
+        super();
+        /**
+         * Explicit mutability marker for compile-time type discrimination.
+         * Always `true` for mutable providers.
+         */
+        this.mutable = true;
+        this.qualifiers = params.qualifiers;
+        this._qualifierValues = new ResultMap();
+        if (params.qualifierValues) {
+            for (const [name, value] of Object.entries(params.qualifierValues)) {
+                const qualifierName = Validate.toQualifierName(name).orThrow();
+                this._qualifierValues.set(qualifierName, value);
+            }
+        }
+    }
+    /**
+     * Creates a new {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} object.
+     * @param params - {@link Runtime.ISimpleContextQualifierProviderCreateParams | Parameters} used to create the provider.
+     * @returns `Success` with the new {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params) {
+        return captureResult(() => new SimpleContextQualifierProvider(params));
+    }
+    /**
+     * Gets a qualifier value by its name, index, or qualifier object.
+     * @param nameOrIndexOrQualifier - The {@link QualifierName | qualifier name}, {@link QualifierIndex | index}, or {@link Qualifiers.Qualifier | qualifier object} to look up.
+     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    get(nameOrIndexOrQualifier) {
+        return this._resolveQualifierName(nameOrIndexOrQualifier).onSuccess((qualifierName) => {
+            return this._qualifierValues.get(qualifierName);
+        });
+    }
+    /**
+     * Gets a validated qualifier context value by its name, index, or qualifier object.
+     * TODO: Implement validation logic using qualifier collectors.
+     * @param nameOrIndexOrQualifier - The {@link QualifierName | qualifier name}, {@link QualifierIndex | index}, or {@link Qualifiers.Qualifier | qualifier object} to look up.
+     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found, invalid, or an error occurs.
+     */
+    getValidated(nameOrIndexOrQualifier) {
+        return this._resolveQualifier(nameOrIndexOrQualifier).onSuccess((qualifier) => {
+            return this._qualifierValues.get(qualifier.name).asResult.onSuccess((value) => {
+                return qualifier.validateContextValue(value);
+            });
+        });
+    }
+    /**
+     * Checks if a qualifier value exists with the given name.
+     * @param name - The {@link QualifierName | qualifier name} to check.
+     * @returns `Success` with `true` if the qualifier value exists, `false` if it doesn't,
+     * or `Failure` with an error message if an error occurs during the check.
+     */
+    has(name) {
+        return succeed(this._qualifierValues.has(name));
+    }
+    /**
+     * Gets all available qualifier names in this context.
+     * @returns `Success` with an array of all {@link QualifierName | qualifier names},
+     * or `Failure` with an error message if an error occurs.
+     */
+    getNames() {
+        return succeed(Array.from(this._qualifierValues.keys()));
+    }
+    /**
+     * Sets a qualifier value in this provider.
+     * @param name - The {@link QualifierName | qualifier name} to set.
+     * @param value - The {@link QualifierContextValue | qualifier context value} to set.
+     * @returns `Success` with the set {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    set(name, value) {
+        this._qualifierValues.set(name, value);
+        return succeed(value);
+    }
+    /**
+     * Removes a qualifier value from this provider.
+     * @param name - The {@link QualifierName | qualifier name} to remove.
+     * @returns `Success` with the removed {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if not found or an error occurs.
+     * @public
+     */
+    remove(name) {
+        return this._qualifierValues.get(name).onSuccess((value) => {
+            this._qualifierValues.delete(name);
+            return succeedWithDetail(value, 'success');
+        });
+    }
+    /**
+     * Gets the number of qualifier values in this provider.
+     * @returns The count of qualifier values.
+     * @public
+     */
+    get size() {
+        return this._qualifierValues.size;
+    }
+    /**
+     * Clears all qualifier values from this provider.
+     * @public
+     */
+    clear() {
+        this._qualifierValues.clear();
+    }
+    /**
+     * Resolves a qualifier from a name, index, or qualifier object.
+     * @param nameOrIndexOrQualifier - The input to resolve.
+     * @returns `Success` with the {@link Qualifier | qualifier} if successful,
+     * or `Failure` with an error message if not found or invalid.
+     * @internal
+     */
+    _resolveQualifier(nameOrIndexOrQualifier) {
+        if (nameOrIndexOrQualifier instanceof Qualifier) {
+            return succeed(nameOrIndexOrQualifier);
+        }
+        /* c8 ignore next 16 - functional code tested but coverage intermittently missed */
+        if (typeof nameOrIndexOrQualifier === 'string') {
+            return this.qualifiers.validating
+                .get(nameOrIndexOrQualifier)
+                .withErrorFormat((error) => `${nameOrIndexOrQualifier}: invalid qualifier name.`);
+        }
+        if (typeof nameOrIndexOrQualifier === 'number') {
+            return this.qualifiers
+                .getAt(nameOrIndexOrQualifier)
+                .withErrorFormat((error) => `${nameOrIndexOrQualifier}: invalid qualifier index.`);
+        }
+        return SimpleContextQualifierProvider._qualifierNameFromQualifierLike(nameOrIndexOrQualifier)
+            .onSuccess((qualifierName) => this.qualifiers.validating.get(qualifierName))
+            .withErrorFormat((error) => `${nameOrIndexOrQualifier}: invalid Qualifier, name or index.`);
+    }
+    /**
+     * Resolves a qualifier name from a name, index, or qualifier object.
+     * @param nameOrIndexOrQualifier - The input to resolve.
+     * @returns `Success` with the {@link QualifierName | qualifier name} if successful,
+     * or `Failure` with an error message if not found or invalid.
+     * @internal
+     */
+    _resolveQualifierName(nameOrIndexOrQualifier) {
+        return this._resolveQualifier(nameOrIndexOrQualifier).onSuccess((qualifier) => succeed(qualifier.name));
+    }
+    /**
+     * Resolves a qualifier name from a qualifier-like object.
+     * @param nameOrIndexOrQualifier - The input to resolve.
+     * @returns `Success` with the {@link QualifierName | qualifier name} if successful,
+     * or `Failure` with an error message if not found or invalid.
+     * @internal
+     */
+    static _qualifierNameFromQualifierLike(nameOrIndexOrQualifier) {
+        return Converters.isA('Qualifier-like object', (v) => typeof v === 'object' &&
+            v !== null &&
+            'name' in v &&
+            typeof v.name === 'string')
+            .map((v) => CommonConverters.qualifierName.convert(v.name))
+            .convert(nameOrIndexOrQualifier);
+    }
+}
+//# sourceMappingURL=simpleContextQualifierProvider.js.map

package/dist/packlets/runtime/context/validatingSimpleContextQualifierProvider.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { captureResult } from '@fgv/ts-utils';
+import { SimpleContextQualifierProvider } from './simpleContextQualifierProvider';
+import { MutableContextQualifierProviderValidator } from './contextQualifierProviderValidator';
+/**
+ * A {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} with a
+ * {@link Runtime.Context.MutableContextQualifierProviderValidator | validator} property that enables
+ * validated use of the underlying provider with string keys and values.
+ * This eliminates the need for type casting in consumer code.
+ * @public
+ */
+export class ValidatingSimpleContextQualifierProvider extends SimpleContextQualifierProvider {
+    /**
+     * Constructor for a {@link Runtime.ValidatingSimpleContextQualifierProvider | ValidatingSimpleContextQualifierProvider} object.
+     * @param params - {@link Runtime.IValidatingSimpleContextQualifierProviderCreateParams | Parameters} used to create the provider.
+     */
+    constructor(params) {
+        // Convert string values to QualifierContextValue for the base class
+        /* c8 ignore next 5 - functional code path tested but coverage intermittently missed */
+        const convertedValues = params.qualifierValues
+            ? Object.fromEntries(Object.entries(params.qualifierValues).map(([key, value]) => [key, value]))
+            : undefined;
+        super({
+            qualifiers: params.qualifiers,
+            qualifierValues: convertedValues
+        });
+        this.validating = new MutableContextQualifierProviderValidator({ provider: this });
+    }
+    /**
+     * Creates a new {@link Runtime.ValidatingSimpleContextQualifierProvider | ValidatingSimpleContextQualifierProvider} object.
+     * @param params - {@link Runtime.IValidatingSimpleContextQualifierProviderCreateParams | Parameters} used to create the provider.
+     * @returns `Success` with the new {@link Runtime.ValidatingSimpleContextQualifierProvider | ValidatingSimpleContextQualifierProvider} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params) {
+        return captureResult(() => new ValidatingSimpleContextQualifierProvider(params));
+    }
+}
+//# sourceMappingURL=validatingSimpleContextQualifierProvider.js.map

package/dist/packlets/runtime/iResourceManager.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export {};
+//# sourceMappingURL=iResourceManager.js.map

package/dist/packlets/runtime/index.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export * from './compiledResourceCollection';
+export * from './iResourceManager';
+export * from './context/simpleContextQualifierProvider';
+export * from './context/validatingSimpleContextQualifierProvider';
+export * from './resourceResolver';
+export * from './resourceTreeResolver';
+export * from './conditionSetResolutionResult';
+export * from './cacheListener';
+export * from './cacheMetrics';
+import * as Context from './context';
+import * as ResourceTree from './resource-tree';
+export { Context, ResourceTree };
+//# sourceMappingURL=index.js.map