@fgv/ts-res 4.5.0-3 → 5.0.0-10

package/lib/packlets/runtime/compiledResourceCollection.d.ts

@@ -0,0 +1,167 @@
+import { Collections, Result } from '@fgv/ts-utils';
+import { ReadOnlyConditionCollector, ReadOnlyConditionSetCollector } from '../conditions';
+import { ReadOnlyAbstractDecisionCollector } from '../decisions';
+import { QualifierCollector } from '../qualifiers';
+import { ResourceType, ResourceTypeCollector } from '../resource-types';
+import { QualifierType, QualifierTypeCollector } from '../qualifier-types';
+import { ResourceId } from '../common';
+import { IResourceManager, IResource } from './iResourceManager';
+import * as ResourceJson from '../resource-json';
+import { IReadOnlyResourceTreeRoot } from './resource-tree';
+import * as Context from '../context';
+/**
+ * Interface for parameters to create a {@link Runtime.CompiledResourceCollection | CompiledResourceCollection}.
+ * @public
+ */
+export interface ICompiledResourceCollectionCreateParams {
+    /**
+     * The compiled resource collection data.
+     */
+    compiledCollection: ResourceJson.Compiled.ICompiledResourceCollection;
+    /**
+     * Map of qualifier type names to qualifier type objects.
+     */
+    qualifierTypes: Collections.IReadOnlyResultMap<string, QualifierType>;
+    /**
+     * Map of resource type names to resource type objects.
+     */
+    resourceTypes: Collections.IReadOnlyResultMap<string, ResourceType>;
+}
+/**
+ * A compiled resource collection implements {@link Runtime.IResourceManager | IResourceManager}
+ * by reconstructing runtime objects from compiled data. This provides an efficient way to load
+ * and use pre-compiled resource collections without rebuilding them from scratch.
+ * @public
+ */
+export declare class CompiledResourceCollection implements IResourceManager<IResource> {
+    readonly conditions: ReadOnlyConditionCollector;
+    readonly conditionSets: ReadOnlyConditionSetCollector;
+    readonly decisions: ReadOnlyAbstractDecisionCollector;
+    private readonly _qualifierTypes;
+    private readonly _qualifiers;
+    private readonly _resourceTypes;
+    private readonly _builtResources;
+    private _cachedResourceTree?;
+    /**
+     * A {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} which
+     * contains the {@link QualifierTypes.QualifierType | qualifier types} used in this collection.
+     */
+    get qualifierTypes(): QualifierTypeCollector;
+    /**
+     * A {@link Qualifiers.QualifierCollector | QualifierCollector} which
+     * contains the {@link Qualifiers.Qualifier | qualifiers} used in this collection.
+     */
+    get qualifiers(): QualifierCollector;
+    /**
+     * A {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector} which
+     * contains the {@link ResourceTypes.ResourceType | resource types} used in this collection.
+     */
+    get resourceTypes(): ResourceTypeCollector;
+    /**
+     * {@inheritdoc Runtime.IResourceManager.builtResources}
+     */
+    get builtResources(): Collections.IReadOnlyValidatingResultMap<ResourceId, IResource>;
+    /**
+     * {@inheritdoc Runtime.IResourceManager.numResources}
+     */
+    get numResources(): number;
+    protected _numCandidates?: number;
+    /**
+     * {@inheritdoc Runtime.IResourceManager.numCandidates}
+     */
+    get numCandidates(): number;
+    /**
+     * Constructor for a {@link Runtime.CompiledResourceCollection | CompiledResourceCollection} object.
+     * @param params - Parameters to create a new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection}.
+     * @internal
+     */
+    protected constructor(params: ICompiledResourceCollectionCreateParams);
+    /**
+     * Creates a new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection} object.
+     * @param params - Parameters to create a new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection}.
+     * @returns `Success` with the new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: ICompiledResourceCollectionCreateParams): Result<CompiledResourceCollection>;
+    /**
+     * {@inheritdoc Runtime.IResourceManager.getBuiltResource}
+     */
+    getBuiltResource(id: string): Result<IResource>;
+    /**
+     * {@inheritdoc Runtime.IResourceManager.validateContext}
+     */
+    validateContext(context: Context.IContextDecl): Result<Context.IValidatedContextDecl>;
+    /**
+     * Gets a resource tree built from the resources in this collection.
+     * The tree provides hierarchical access to resources based on their ResourceId structure.
+     * For example, resources with IDs like "app.messages.welcome" create a tree structure
+     * where "app" and "messages" are branch nodes, and "welcome" is a leaf containing the resource.
+     *
+     * String-based validation is available through the `children.validating` property,
+     * allowing callers to use `tree.children.validating.getById(stringId)` for validated access.
+     *
+     * Uses lazy initialization with caching for performance.
+     * @returns Result containing the resource tree root, or failure if tree construction fails
+     * @public
+     */
+    getBuiltResourceTree(): Result<IReadOnlyResourceTreeRoot<IResource>>;
+    /**
+     * Reconstructs a QualifierTypeCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param qualifierTypes - Map of qualifier type names to qualifier type objects
+     * @returns The reconstructed QualifierTypeCollector
+     * @internal
+     */
+    private _buildQualifierTypes;
+    /**
+     * Reconstructs a QualifierCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param qualifierTypes - The reconstructed QualifierTypeCollector
+     * @returns The reconstructed QualifierCollector
+     * @internal
+     */
+    private _buildQualifiers;
+    /**
+     * Reconstructs a ResourceTypeCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param resourceTypes - Map of resource type names to resource type objects
+     * @returns The reconstructed ResourceTypeCollector
+     * @internal
+     */
+    private _buildResourceTypes;
+    /**
+     * Reconstructs a ConditionCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param qualifiers - The reconstructed QualifierCollector
+     * @returns The reconstructed ConditionCollector
+     * @internal
+     */
+    private _buildConditions;
+    /**
+     * Reconstructs a ConditionSetCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param conditions - The reconstructed ConditionCollector
+     * @returns The reconstructed ConditionSetCollector
+     * @internal
+     */
+    private _buildConditionSets;
+    /**
+     * Reconstructs an AbstractDecisionCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param conditionSets - The reconstructed ConditionSetCollector
+     * @returns The reconstructed AbstractDecisionCollector
+     * @internal
+     */
+    private _buildDecisions;
+    /**
+     * Reconstructs a ValidatingResultMap of resources from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param resourceTypes - The reconstructed ResourceTypeCollector
+     * @param decisions - The reconstructed AbstractDecisionCollector
+     * @returns The reconstructed ValidatingResultMap of resources
+     * @internal
+     */
+    private _buildResources;
+}
+//# sourceMappingURL=compiledResourceCollection.d.ts.map

package/lib/packlets/runtime/compiledResourceCollection.d.ts.map

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

package/lib/packlets/runtime/compiledResourceCollection.js

@@ -0,0 +1,466 @@
+"use strict";
+/*
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompiledResourceCollection = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const conditions_1 = require("../conditions");
+const decisions_1 = require("../decisions");
+const qualifiers_1 = require("../qualifiers");
+const resource_types_1 = require("../resource-types");
+const qualifier_types_1 = require("../qualifier-types");
+const common_1 = require("../common");
+const ts_json_base_1 = require("@fgv/ts-json-base");
+const decisions_2 = require("../decisions");
+const Validate = __importStar(require("./validate"));
+const resource_tree_1 = require("./resource-tree");
+const Context = __importStar(require("../context"));
+/**
+ * A compiled resource collection implements {@link Runtime.IResourceManager | IResourceManager}
+ * by reconstructing runtime objects from compiled data. This provides an efficient way to load
+ * and use pre-compiled resource collections without rebuilding them from scratch.
+ * @public
+ */
+class CompiledResourceCollection {
+    /**
+     * A {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} which
+     * contains the {@link QualifierTypes.QualifierType | qualifier types} used in this collection.
+     */
+    get qualifierTypes() {
+        return this._qualifierTypes;
+    }
+    /**
+     * A {@link Qualifiers.QualifierCollector | QualifierCollector} which
+     * contains the {@link Qualifiers.Qualifier | qualifiers} used in this collection.
+     */
+    get qualifiers() {
+        return this._qualifiers;
+    }
+    /**
+     * A {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector} which
+     * contains the {@link ResourceTypes.ResourceType | resource types} used in this collection.
+     */
+    get resourceTypes() {
+        return this._resourceTypes;
+    }
+    /**
+     * {@inheritdoc Runtime.IResourceManager.builtResources}
+     */
+    get builtResources() {
+        return this._builtResources;
+    }
+    /**
+     * {@inheritdoc Runtime.IResourceManager.numResources}
+     */
+    get numResources() {
+        return this._builtResources.size;
+    }
+    /**
+     * {@inheritdoc Runtime.IResourceManager.numCandidates}
+     */
+    get numCandidates() {
+        if (this._numCandidates === undefined) {
+            this._numCandidates = [...this._builtResources.values()].reduce((acc, resource) => acc + resource.candidates.length, 0);
+        }
+        return this._numCandidates;
+    }
+    /**
+     * Constructor for a {@link Runtime.CompiledResourceCollection | CompiledResourceCollection} object.
+     * @param params - Parameters to create a new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection}.
+     * @internal
+     */
+    constructor(params) {
+        // Reconstruct collectors from compiled data
+        this._qualifierTypes = this._buildQualifierTypes(params.compiledCollection, params.qualifierTypes).orThrow();
+        this._qualifiers = this._buildQualifiers(params.compiledCollection, this._qualifierTypes).orThrow();
+        this._resourceTypes = this._buildResourceTypes(params.compiledCollection, params.resourceTypes).orThrow();
+        // Build collectors from compiled data
+        const conditionCollector = this._buildConditions(params.compiledCollection, this._qualifiers).orThrow();
+        const conditionSetCollector = this._buildConditionSets(params.compiledCollection, conditionCollector).orThrow();
+        const decisionCollector = this._buildDecisions(params.compiledCollection, conditionSetCollector).orThrow();
+        this.conditions = conditionCollector;
+        this.conditionSets = conditionSetCollector;
+        this.decisions = decisionCollector;
+        // Build resources from compiled data
+        this._builtResources = this._buildResources(params.compiledCollection, this._resourceTypes, decisionCollector).orThrow();
+    }
+    /**
+     * Creates a new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection} object.
+     * @param params - Parameters to create a new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection}.
+     * @returns `Success` with the new {@link Runtime.CompiledResourceCollection | CompiledResourceCollection} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params) {
+        return (0, ts_utils_1.captureResult)(() => new CompiledResourceCollection(params));
+    }
+    /**
+     * {@inheritdoc Runtime.IResourceManager.getBuiltResource}
+     */
+    getBuiltResource(id) {
+        return this._builtResources.validating.get(id);
+    }
+    /**
+     * {@inheritdoc Runtime.IResourceManager.validateContext}
+     */
+    validateContext(context) {
+        return Context.Convert.validatedContextDecl.convert(context, {
+            qualifiers: this._qualifiers
+        });
+    }
+    /**
+     * Gets a resource tree built from the resources in this collection.
+     * The tree provides hierarchical access to resources based on their ResourceId structure.
+     * For example, resources with IDs like "app.messages.welcome" create a tree structure
+     * where "app" and "messages" are branch nodes, and "welcome" is a leaf containing the resource.
+     *
+     * String-based validation is available through the `children.validating` property,
+     * allowing callers to use `tree.children.validating.getById(stringId)` for validated access.
+     *
+     * Uses lazy initialization with caching for performance.
+     * @returns Result containing the resource tree root, or failure if tree construction fails
+     * @public
+     */
+    getBuiltResourceTree() {
+        if (this._cachedResourceTree) {
+            return (0, ts_utils_1.succeed)(this._cachedResourceTree);
+        }
+        // Convert all built resources to [ResourceId, IResource] pairs
+        const resources = [];
+        for (const [id, resource] of this._builtResources.entries()) {
+            resources.push([id, resource]);
+        }
+        // Create the resource tree with lazy initialization
+        return resource_tree_1.ReadOnlyResourceTreeRoot.create(resources).onSuccess((tree) => {
+            this._cachedResourceTree = tree;
+            return (0, ts_utils_1.succeed)(tree);
+        });
+    }
+    /**
+     * Reconstructs a QualifierTypeCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param qualifierTypes - Map of qualifier type names to qualifier type objects
+     * @returns The reconstructed QualifierTypeCollector
+     * @internal
+     */
+    _buildQualifierTypes(compiled, qualifierTypes) {
+        return (0, ts_utils_1.mapResults)(compiled.qualifierTypes.map((compiledQualifierType) => qualifierTypes.get(compiledQualifierType.name))).onSuccess((referencedQualifierTypes) => {
+            return qualifier_types_1.QualifierTypeCollector.create({
+                qualifierTypes: referencedQualifierTypes
+            });
+        });
+    }
+    /**
+     * Reconstructs a QualifierCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param qualifierTypes - The reconstructed QualifierTypeCollector
+     * @returns The reconstructed QualifierCollector
+     * @internal
+     */
+    _buildQualifiers(compiled, qualifierTypes) {
+        return (0, ts_utils_1.mapResults)(compiled.qualifiers.map((compiledQualifier) => {
+            return qualifierTypes.getAt(compiledQualifier.type).onSuccess((qualifierType) => {
+                return (0, ts_utils_1.succeed)({
+                    name: compiledQualifier.name,
+                    typeName: qualifierType.name,
+                    defaultPriority: compiledQualifier.defaultPriority
+                });
+            });
+        })).onSuccess((qualifierDecls) => {
+            return qualifiers_1.QualifierCollector.create({
+                qualifierTypes,
+                qualifiers: qualifierDecls
+            });
+        });
+    }
+    /**
+     * Reconstructs a ResourceTypeCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param resourceTypes - Map of resource type names to resource type objects
+     * @returns The reconstructed ResourceTypeCollector
+     * @internal
+     */
+    _buildResourceTypes(compiled, resourceTypes) {
+        return (0, ts_utils_1.mapResults)(compiled.resourceTypes.map((compiledResourceType) => resourceTypes.get(compiledResourceType.name))).onSuccess((referencedResourceTypes) => {
+            return resource_types_1.ResourceTypeCollector.create({
+                resourceTypes: referencedResourceTypes
+            });
+        });
+    }
+    /**
+     * Reconstructs a ConditionCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param qualifiers - The reconstructed QualifierCollector
+     * @returns The reconstructed ConditionCollector
+     * @internal
+     */
+    _buildConditions(compiled, qualifiers) {
+        var _a;
+        const errors = new ts_utils_1.MessageAggregator();
+        const conditionCollectorResult = conditions_1.ConditionCollector.create({ qualifiers });
+        /* c8 ignore next 3 - defensive coding for ConditionCollector creation failure */
+        if (conditionCollectorResult.isFailure()) {
+            return conditionCollectorResult;
+        }
+        const conditionCollector = conditionCollectorResult.value;
+        for (const [index, compiledCondition] of compiled.conditions.entries()) {
+            const qualifierResult = qualifiers.getAt(compiledCondition.qualifierIndex);
+            if (qualifierResult.isFailure()) {
+                errors.addMessage(`Invalid qualifier index ${compiledCondition.qualifierIndex} at condition ${index}: ${qualifierResult.message}`);
+                continue;
+            }
+            const qualifier = qualifierResult.value;
+            /* c8 ignore next 1 - not really testable atm as "matches" is the only supported operator */
+            const operator = (_a = compiledCondition.operator) !== null && _a !== void 0 ? _a : 'matches'; // Default to 'matches' if not provided
+            const conditionDecl = {
+                qualifierName: qualifier.name,
+                value: compiledCondition.value,
+                operator,
+                priority: compiledCondition.priority,
+                scoreAsDefault: compiledCondition.scoreAsDefault
+            };
+            const conditionResult = conditionCollector.validating.add(conditionDecl);
+            /* c8 ignore next 4 - defensive coding for condition addition failure */
+            if (conditionResult.isFailure()) {
+                errors.addMessage(`Failed to add condition at index ${index}: ${conditionResult.message}`);
+                continue;
+            }
+            const condition = conditionResult.value;
+            // Validate that the assigned index matches our expected index
+            const expectedIndexResult = common_1.Convert.conditionIndex.convert(index);
+            /* c8 ignore next 4 - defensive coding for invalid condition index conversion */
+            if (expectedIndexResult.isFailure()) {
+                errors.addMessage(`Invalid condition index ${index}: ${expectedIndexResult.message}`);
+                continue;
+            }
+            const expectedIndex = expectedIndexResult.value;
+            /* c8 ignore next 5 - defensive coding for condition index mismatch */
+            if (condition.index !== expectedIndex) {
+                errors.addMessage(`Index mismatch at condition ${index}: expected ${expectedIndex}, got ${condition.index}`);
+            }
+        }
+        return errors.hasMessages ? (0, ts_utils_1.fail)(errors.toString()) : (0, ts_utils_1.succeed)(conditionCollector);
+    }
+    /**
+     * Reconstructs a ConditionSetCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param conditions - The reconstructed ConditionCollector
+     * @returns The reconstructed ConditionSetCollector
+     * @internal
+     */
+    _buildConditionSets(compiled, conditions) {
+        const errors = new ts_utils_1.MessageAggregator();
+        const conditionSetCollectorResult = conditions_1.ConditionSetCollector.create({ conditions });
+        /* c8 ignore next 3 - defensive coding for ConditionSetCollector creation failure */
+        if (conditionSetCollectorResult.isFailure()) {
+            return conditionSetCollectorResult;
+        }
+        const conditionSetCollector = conditionSetCollectorResult.value;
+        for (const [index, compiledConditionSet] of compiled.conditionSets.entries()) {
+            const referencedConditionsResult = (0, ts_utils_1.mapResults)(compiledConditionSet.conditions.map((conditionIndex) => conditions.getAt(conditionIndex)));
+            if (referencedConditionsResult.isFailure()) {
+                errors.addMessage(`Failed to resolve conditions for condition set ${index}: ${referencedConditionsResult.message}`);
+                continue;
+            }
+            const referencedConditions = referencedConditionsResult.value;
+            const conditionSetResult = conditionSetCollector.validating.getOrAdd(referencedConditions);
+            /* c8 ignore next 4 - defensive coding for condition set addition failure */
+            if (conditionSetResult.isFailure()) {
+                errors.addMessage(`Failed to add condition set at index ${index}: ${conditionSetResult.message}`);
+                continue;
+            }
+            const conditionSet = conditionSetResult.value;
+            // Validate that the assigned index matches our expected index
+            const expectedIndexResult = common_1.Convert.conditionSetIndex.convert(index);
+            /* c8 ignore next 4 - defensive coding for invalid condition set index conversion */
+            if (expectedIndexResult.isFailure()) {
+                errors.addMessage(`Invalid condition set index ${index}: ${expectedIndexResult.message}`);
+                continue;
+            }
+            const expectedIndex = expectedIndexResult.value;
+            /* c8 ignore next 5 - defensive coding for condition set index mismatch */
+            if (conditionSet.index !== expectedIndex) {
+                errors.addMessage(`Index mismatch at condition set ${index}: expected ${expectedIndex}, got ${conditionSet.index}`);
+            }
+        }
+        return errors.hasMessages ? (0, ts_utils_1.fail)(errors.toString()) : (0, ts_utils_1.succeed)(conditionSetCollector);
+    }
+    /**
+     * Reconstructs an AbstractDecisionCollector from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param conditionSets - The reconstructed ConditionSetCollector
+     * @returns The reconstructed AbstractDecisionCollector
+     * @internal
+     */
+    _buildDecisions(compiled, conditionSets) {
+        const errors = new ts_utils_1.MessageAggregator();
+        const decisionCollectorResult = decisions_1.AbstractDecisionCollector.create({ conditionSets });
+        /* c8 ignore next 3 - defensive coding for AbstractDecisionCollector creation failure */
+        if (decisionCollectorResult.isFailure()) {
+            return decisionCollectorResult;
+        }
+        const decisionCollector = decisionCollectorResult.value;
+        for (const [index, compiledDecision] of compiled.decisions.entries()) {
+            const referencedConditionSetsResult = (0, ts_utils_1.mapResults)(compiledDecision.conditionSets.map((conditionSetIndex) => conditionSets.getAt(conditionSetIndex)));
+            if (referencedConditionSetsResult.isFailure()) {
+                errors.addMessage(`Failed to resolve condition sets for decision ${index}: ${referencedConditionSetsResult.message}`);
+                continue;
+            }
+            const referencedConditionSets = referencedConditionSetsResult.value;
+            const decisionResult = decisionCollector.validating.getOrAdd(referencedConditionSets);
+            /* c8 ignore next 4 - defensive coding for decision addition failure */
+            if (decisionResult.isFailure()) {
+                errors.addMessage(`Failed to add decision at index ${index}: ${decisionResult.message}`);
+                continue;
+            }
+            const decision = decisionResult.value;
+            // Validate that the assigned index matches our expected index
+            const expectedIndexResult = common_1.Convert.decisionIndex.convert(index);
+            /* c8 ignore next 4 - defensive coding for invalid decision index conversion */
+            if (expectedIndexResult.isFailure()) {
+                errors.addMessage(`Invalid decision index ${index}: ${expectedIndexResult.message}`);
+                continue;
+            }
+            const expectedIndex = expectedIndexResult.value;
+            /* c8 ignore next 5 - defensive coding for decision index mismatch */
+            if (decision.index !== expectedIndex) {
+                errors.addMessage(`Index mismatch at decision ${index}: expected ${expectedIndex}, got ${decision.index}`);
+            }
+        }
+        return errors.hasMessages ? (0, ts_utils_1.fail)(errors.toString()) : (0, ts_utils_1.succeed)(decisionCollector);
+    }
+    /**
+     * Reconstructs a ValidatingResultMap of resources from compiled data.
+     * @param compiled - The compiled resource collection
+     * @param resourceTypes - The reconstructed ResourceTypeCollector
+     * @param decisions - The reconstructed AbstractDecisionCollector
+     * @returns The reconstructed ValidatingResultMap of resources
+     * @internal
+     */
+    _buildResources(compiled, resourceTypes, decisions) {
+        const errors = new ts_utils_1.MessageAggregator();
+        const resourceMap = new ts_utils_1.ValidatingResultMap({
+            converters: new ts_utils_1.Collections.KeyValueConverters({
+                key: common_1.Convert.resourceId,
+                value: (from) => {
+                    return Validate.resource.validate(from);
+                }
+            })
+        });
+        for (const compiledResource of compiled.resources) {
+            const resourceTypeResult = resourceTypes.getAt(compiledResource.type);
+            if (resourceTypeResult.isFailure()) {
+                errors.addMessage(`Invalid resource type index ${compiledResource.type} for resource ${compiledResource.id}: ${resourceTypeResult.message}`);
+                continue;
+            }
+            const resourceType = resourceTypeResult.value;
+            const decisionResult = decisions.getAt(compiledResource.decision);
+            if (decisionResult.isFailure()) {
+                errors.addMessage(`Invalid decision index ${compiledResource.decision} for resource ${compiledResource.id}: ${decisionResult.message}`);
+                continue;
+            }
+            const decision = decisionResult.value;
+            // Build candidates from compiled data
+            const candidateDeclsResult = (0, ts_utils_1.mapResults)(compiledResource.candidates.map((compiledCandidate) => ts_json_base_1.Converters.jsonObject.convert(compiledCandidate.json).onSuccess((json) => {
+                return (0, ts_utils_1.succeed)({
+                    json,
+                    isPartial: compiledCandidate.isPartial,
+                    mergeMethod: compiledCandidate.mergeMethod
+                });
+            })));
+            if (candidateDeclsResult.isFailure()) {
+                errors.addMessage(`Failed to convert candidate JSON for resource ${compiledResource.id}: ${candidateDeclsResult.message}`);
+                continue;
+            }
+            const candidateDecls = candidateDeclsResult.value;
+            // Create minimal candidates that implement IResourceCandidate
+            const candidates = candidateDecls.map((candidateDecl) => ({
+                json: candidateDecl.json,
+                isPartial: candidateDecl.isPartial,
+                mergeMethod: candidateDecl.mergeMethod
+            }));
+            // Create a ConcreteDecision from the abstract decision and candidate values
+            const candidatesWithConditionSets = decision.candidates.map((baseCandidate, idx) => ({
+                conditionSet: baseCandidate.conditionSet,
+                value: candidates[idx].json
+            }));
+            const concreteDecisionResult = decisions_2.ConcreteDecision.create({
+                decisions,
+                candidates: candidatesWithConditionSets
+            });
+            /* c8 ignore next 6 - defensive coding for ConcreteDecision creation failure */
+            if (concreteDecisionResult.isFailure()) {
+                errors.addMessage(`Failed to create concrete decision for resource ${compiledResource.id}: ${concreteDecisionResult.message}`);
+                continue;
+            }
+            const concreteDecision = concreteDecisionResult.value;
+            // Create minimal resource that implements IResource
+            const resource = {
+                id: compiledResource.id,
+                resourceType,
+                decision: concreteDecision,
+                candidates
+            };
+            const setResult = resourceMap.set(compiledResource.id, resource);
+            /* c8 ignore next 3 - defensive coding for resource map set failure */
+            if (setResult.isFailure()) {
+                errors.addMessage(`Failed to add resource ${compiledResource.id}: ${setResult.message}`);
+            }
+        }
+        return errors.hasMessages ? (0, ts_utils_1.fail)(errors.toString()) : (0, ts_utils_1.succeed)(resourceMap);
+    }
+}
+exports.CompiledResourceCollection = CompiledResourceCollection;
+//# sourceMappingURL=compiledResourceCollection.js.map