@fgv/ts-res 5.0.1-0 → 5.0.1-1

package/dist/ts-res.d.ts

@@ -10,6 +10,7 @@ import { IReadOnlyResultMap } from '@fgv/ts-utils';
 import { JsonCompatible } from '@fgv/ts-json-base';
 import { JsonObject } from '@fgv/ts-json-base';
 import { JsonValue } from '@fgv/ts-json-base';
+import { Logging } from '@fgv/ts-utils';
 import { ObjectConverter } from '@fgv/ts-utils';
 import { Result } from '@fgv/ts-utils';
 import { ResultMap } from '@fgv/ts-utils';
@@ -995,6 +996,10 @@ declare class CompiledResourceCollection implements IResourceManager<IResource>
      * contains the {@link Qualifiers.Qualifier | qualifiers} used in this collection.
      */
     get qualifiers(): IReadOnlyQualifierCollector;
+    /**
+     * The resource IDs contained in this compiled resource collection.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * A {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector} which
      * contains the {@link ResourceTypes.ResourceType | resource types} used in this collection.
@@ -2552,6 +2557,150 @@ declare const DefaultResourceTypes: ReadonlyArray<ResourceTypes.Config.IResource
  */
 declare const DefaultSystemConfiguration: ISystemConfiguration;
 
+/**
+ * Class for generating resource deltas between baseline and delta resolvers.
+ * Creates partial/augment candidates for updated resources and full/replace candidates for new resources.
+ * Uses Diff.jsonThreeWayDiff for efficient delta computation.
+ * @public
+ */
+declare class DeltaGenerator {
+    /**
+     * The baseline resource resolver to compare against.
+     * @internal
+     */
+    private readonly _baselineResolver;
+    /**
+     * The delta resource resolver containing changes.
+     * @internal
+     */
+    private readonly _deltaResolver;
+    /**
+     * The resource manager to clone and update.
+     * @internal
+     */
+    private readonly _resourceManager;
+    /**
+     * Logger for status and error reporting.
+     * @internal
+     */
+    private readonly _logger;
+    /**
+     * Constructor for a {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @internal
+     */
+    protected constructor(params: IDeltaGeneratorParams);
+    /**
+     * Creates a new {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @returns `Success` with the new {@link Resources.DeltaGenerator | DeltaGenerator} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IDeltaGeneratorParams): Result<DeltaGenerator>;
+    /**
+     * Generates deltas between baseline and delta resolvers.
+     * Creates a cloned resource manager with partial/augment candidates for updates
+     * and full/replace candidates for new resources.
+     *
+     * @param options - Options controlling delta generation behavior.
+     * @returns `Success` with the updated resource manager if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    generate(options?: IDeltaGeneratorOptions): Result<ResourceManagerBuilder>;
+    /**
+     * Validates the provided context declaration.
+     * @param context - The context declaration to validate.
+     * @returns `Success` with the validated context if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _validateContext;
+    /**
+     * Enumerates target resource IDs for delta generation.
+     * If specific resource IDs are provided, uses those. Otherwise, discovers all resources
+     * from both the baseline resource manager and the delta resolver to ensure comprehensive
+     * coverage of all potential resources.
+     *
+     * @param requestedIds - Optional array of specific resource IDs to target.
+     * @param context - The validated context to use for resource discovery.
+     * @returns `Success` with array of resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _enumerateTargetResources;
+    /**
+     * Discovers all unique resource IDs from both baseline and delta resolvers.
+     * Creates a union of resource IDs from the baseline resource manager and delta resolver
+     * to ensure comprehensive coverage of all resources.
+     *
+     * @returns `Success` with array of unique resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _discoverAllResourceIds;
+    /**
+     * Creates a clone of the resource manager for delta operations.
+     * @returns `Success` with the cloned resource manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _cloneResourceManager;
+    /**
+     * Generates deltas for the specified resources and adds them to the cloned manager.
+     *
+     * @param clonedManager - The cloned resource manager to update.
+     * @param resourceIds - Array of resource IDs to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the updated manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _generateDeltas;
+    /**
+     * Generates a delta for a single resource and adds appropriate candidates to the manager.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the resource delta result if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _generateResourceDelta;
+    /**
+     * Checks if two JSON values are identical.
+     * @param value1 - First value to compare.
+     * @param value2 - Second value to compare.
+     * @returns True if values are identical, false otherwise.
+     * @internal
+     */
+    private _areValuesIdentical;
+    /**
+     * Creates a new resource candidate for a newly discovered resource.
+     * Uses full/replace merge method since this is a completely new resource.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the new resource.
+     * @param value - The resolved value for the new resource.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private _createNewResourceCandidate;
+    /**
+     * Creates a delta candidate for an updated resource.
+     * Computes the difference between baseline and delta values and creates
+     * a partial/augment candidate with only the changed properties.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the updated resource.
+     * @param baselineValue - The baseline resolved value.
+     * @param deltaValue - The delta resolved value.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private _createDeltaCandidate;
+}
+
 /**
  * Type for handling empty branch nodes during tree composition.
  * The handler receives the branch node, names of failed children, and the resolver for recovery attempts.
@@ -3813,6 +3962,49 @@ declare interface IDeclarationOptions {
     normalized?: boolean;
 }
 
+/**
+ * Interface for options controlling delta generation behavior.
+ * @public
+ */
+declare interface IDeltaGeneratorOptions {
+    /**
+     * Context to use when resolving resources. If not provided, uses empty context.
+     */
+    context?: Context.IContextDecl;
+    /**
+     * Array of specific resource IDs to include in delta generation.
+     * If not provided, generates deltas for all resources in the delta resolver.
+     */
+    resourceIds?: ReadonlyArray<string>;
+    /**
+     * Whether to skip resources that haven't changed. Default: true.
+     */
+    skipUnchanged?: boolean;
+}
+
+/**
+ * Interface for parameters to create a {@link Resources.DeltaGenerator | DeltaGenerator}.
+ * @public
+ */
+declare interface IDeltaGeneratorParams {
+    /**
+     * The baseline resource resolver to compare against.
+     */
+    baselineResolver: IResourceResolver;
+    /**
+     * The delta resource resolver containing changes.
+     */
+    deltaResolver: IResourceResolver;
+    /**
+     * The resource manager to clone and update.
+     */
+    resourceManager: ResourceManagerBuilder;
+    /**
+     * Optional logger for status and error reporting.
+     */
+    logger?: Logging.ILogger;
+}
+
 /**
  * @internal
  */
@@ -5266,6 +5458,10 @@ export declare interface IResourceManager<TR extends IResource = IResource> {
      * The number of resources in this resource manager.
      */
     readonly numResources: number;
+    /**
+     * The resource IDs that this resource manager can resolve.
+     */
+    readonly resourceIds: ReadonlyArray<ResourceId>;
     /**
      * The number of candidates in this resource manager.
      */
@@ -5317,6 +5513,10 @@ declare interface IResourceManagerCloneOptions extends IResourceDeclarationOptio
  * @public
  */
 export declare interface IResourceResolver {
+    /**
+     * The resource IDs that this resolver can resolve.
+     */
+    readonly resourceIds: ReadonlyArray<ResourceId>;
     /**
      * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
      * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher
@@ -8457,6 +8657,10 @@ export declare class ResourceManagerBuilder implements IResourceManager<Resource
      * the {@link Resources.ResourceCandidate | resource candidates} in this manager.
      */
     get conditions(): ReadOnlyConditionCollector;
+    /**
+     * The resource IDs that this resource manager can resolve.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * A {@link Conditions.ConditionSetCollector | ConditionSetCollector} which
      * contains the {@link Conditions.ConditionSet | condition sets} used so far by
@@ -8805,6 +9009,10 @@ export declare class ResourceResolver implements IResourceResolver {
      * The readonly qualifier collector that provides qualifier implementations.
      */
     get qualifiers(): IReadOnlyQualifierCollector;
+    /**
+     * The resource IDs that this resolver can resolve.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
      * Each entry stores the resolved {@link Runtime.IConditionMatchResult | condition match result} for
@@ -9032,6 +9240,9 @@ declare namespace Resources {
         CandidateValue,
         ICandidateValueCollectorCreateParams,
         CandidateValueCollector,
+        IDeltaGeneratorParams,
+        IDeltaGeneratorOptions,
+        DeltaGenerator,
         IResourceCandidateCreateParams,
         ICandidateDeclOptions,
         ResourceCandidate,

package/lib/packlets/common/resources.d.ts

@@ -66,6 +66,10 @@ export type CandidateValueKey = Brand<string, 'CandidateValueKey'>;
  * @public
  */
 export interface IResourceResolver {
+    /**
+     * The resource IDs that this resolver can resolve.
+     */
+    readonly resourceIds: ReadonlyArray<ResourceId>;
     /**
      * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
      * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher

package/lib/packlets/resources/deltaGenerator.d.ts

@@ -0,0 +1,189 @@
+import { Logging, Result } from '@fgv/ts-utils';
+import { IResourceResolver } from '../common';
+import { ResourceManagerBuilder } from './resourceManagerBuilder';
+import * as Context from '../context';
+/**
+ * Interface for parameters to create a {@link Resources.DeltaGenerator | DeltaGenerator}.
+ * @public
+ */
+export interface IDeltaGeneratorParams {
+    /**
+     * The baseline resource resolver to compare against.
+     */
+    baselineResolver: IResourceResolver;
+    /**
+     * The delta resource resolver containing changes.
+     */
+    deltaResolver: IResourceResolver;
+    /**
+     * The resource manager to clone and update.
+     */
+    resourceManager: ResourceManagerBuilder;
+    /**
+     * Optional logger for status and error reporting.
+     */
+    logger?: Logging.ILogger;
+}
+/**
+ * Interface for options controlling delta generation behavior.
+ * @public
+ */
+export interface IDeltaGeneratorOptions {
+    /**
+     * Context to use when resolving resources. If not provided, uses empty context.
+     */
+    context?: Context.IContextDecl;
+    /**
+     * Array of specific resource IDs to include in delta generation.
+     * If not provided, generates deltas for all resources in the delta resolver.
+     */
+    resourceIds?: ReadonlyArray<string>;
+    /**
+     * Whether to skip resources that haven't changed. Default: true.
+     */
+    skipUnchanged?: boolean;
+}
+/**
+ * Class for generating resource deltas between baseline and delta resolvers.
+ * Creates partial/augment candidates for updated resources and full/replace candidates for new resources.
+ * Uses Diff.jsonThreeWayDiff for efficient delta computation.
+ * @public
+ */
+export declare class DeltaGenerator {
+    /**
+     * The baseline resource resolver to compare against.
+     * @internal
+     */
+    private readonly _baselineResolver;
+    /**
+     * The delta resource resolver containing changes.
+     * @internal
+     */
+    private readonly _deltaResolver;
+    /**
+     * The resource manager to clone and update.
+     * @internal
+     */
+    private readonly _resourceManager;
+    /**
+     * Logger for status and error reporting.
+     * @internal
+     */
+    private readonly _logger;
+    /**
+     * Constructor for a {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @internal
+     */
+    protected constructor(params: IDeltaGeneratorParams);
+    /**
+     * Creates a new {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @returns `Success` with the new {@link Resources.DeltaGenerator | DeltaGenerator} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IDeltaGeneratorParams): Result<DeltaGenerator>;
+    /**
+     * Generates deltas between baseline and delta resolvers.
+     * Creates a cloned resource manager with partial/augment candidates for updates
+     * and full/replace candidates for new resources.
+     *
+     * @param options - Options controlling delta generation behavior.
+     * @returns `Success` with the updated resource manager if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    generate(options?: IDeltaGeneratorOptions): Result<ResourceManagerBuilder>;
+    /**
+     * Validates the provided context declaration.
+     * @param context - The context declaration to validate.
+     * @returns `Success` with the validated context if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _validateContext;
+    /**
+     * Enumerates target resource IDs for delta generation.
+     * If specific resource IDs are provided, uses those. Otherwise, discovers all resources
+     * from both the baseline resource manager and the delta resolver to ensure comprehensive
+     * coverage of all potential resources.
+     *
+     * @param requestedIds - Optional array of specific resource IDs to target.
+     * @param context - The validated context to use for resource discovery.
+     * @returns `Success` with array of resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _enumerateTargetResources;
+    /**
+     * Discovers all unique resource IDs from both baseline and delta resolvers.
+     * Creates a union of resource IDs from the baseline resource manager and delta resolver
+     * to ensure comprehensive coverage of all resources.
+     *
+     * @returns `Success` with array of unique resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _discoverAllResourceIds;
+    /**
+     * Creates a clone of the resource manager for delta operations.
+     * @returns `Success` with the cloned resource manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _cloneResourceManager;
+    /**
+     * Generates deltas for the specified resources and adds them to the cloned manager.
+     *
+     * @param clonedManager - The cloned resource manager to update.
+     * @param resourceIds - Array of resource IDs to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the updated manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _generateDeltas;
+    /**
+     * Generates a delta for a single resource and adds appropriate candidates to the manager.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the resource delta result if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _generateResourceDelta;
+    /**
+     * Checks if two JSON values are identical.
+     * @param value1 - First value to compare.
+     * @param value2 - Second value to compare.
+     * @returns True if values are identical, false otherwise.
+     * @internal
+     */
+    private _areValuesIdentical;
+    /**
+     * Creates a new resource candidate for a newly discovered resource.
+     * Uses full/replace merge method since this is a completely new resource.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the new resource.
+     * @param value - The resolved value for the new resource.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private _createNewResourceCandidate;
+    /**
+     * Creates a delta candidate for an updated resource.
+     * Computes the difference between baseline and delta values and creates
+     * a partial/augment candidate with only the changed properties.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the updated resource.
+     * @param baselineValue - The baseline resolved value.
+     * @param deltaValue - The delta resolved value.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private _createDeltaCandidate;
+}
+//# sourceMappingURL=deltaGenerator.d.ts.map

package/lib/packlets/resources/deltaGenerator.js

@@ -0,0 +1,344 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaGenerator = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const ts_json_base_1 = require("@fgv/ts-json-base");
+const ts_json_1 = require("@fgv/ts-json");
+/**
+ * Class for generating resource deltas between baseline and delta resolvers.
+ * Creates partial/augment candidates for updated resources and full/replace candidates for new resources.
+ * Uses Diff.jsonThreeWayDiff for efficient delta computation.
+ * @public
+ */
+class DeltaGenerator {
+    /**
+     * Constructor for a {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @internal
+     */
+    constructor(params) {
+        var _a;
+        this._baselineResolver = params.baselineResolver;
+        this._deltaResolver = params.deltaResolver;
+        this._resourceManager = params.resourceManager;
+        this._logger = (_a = params.logger) !== null && _a !== void 0 ? _a : new ts_utils_1.Logging.NoOpLogger();
+    }
+    /**
+     * Creates a new {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @returns `Success` with the new {@link Resources.DeltaGenerator | DeltaGenerator} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params) {
+        return (0, ts_utils_1.captureResult)(() => new DeltaGenerator(params));
+    }
+    /**
+     * Generates deltas between baseline and delta resolvers.
+     * Creates a cloned resource manager with partial/augment candidates for updates
+     * and full/replace candidates for new resources.
+     *
+     * @param options - Options controlling delta generation behavior.
+     * @returns `Success` with the updated resource manager if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    generate(options) {
+        var _a, _b;
+        this._logger.info('Starting delta generation');
+        const context = (_a = options === null || options === void 0 ? void 0 : options.context) !== null && _a !== void 0 ? _a : {};
+        const skipUnchanged = (_b = options === null || options === void 0 ? void 0 : options.skipUnchanged) !== null && _b !== void 0 ? _b : true;
+        return this._validateContext(context)
+            .onSuccess((validatedContext) => this._enumerateTargetResources(options === null || options === void 0 ? void 0 : options.resourceIds, validatedContext))
+            .onSuccess((resourceIds) => {
+            return this._cloneResourceManager()
+                .onSuccess((clonedManager) => this._generateDeltas(clonedManager, resourceIds, context, skipUnchanged))
+                .onSuccess((manager) => {
+                this._logger.info(`Delta generation completed successfully with ${manager.size} resources`);
+                return (0, ts_utils_1.succeed)(manager);
+            });
+        });
+    }
+    /**
+     * Validates the provided context declaration.
+     * @param context - The context declaration to validate.
+     * @returns `Success` with the validated context if successful, `Failure` otherwise.
+     * @internal
+     */
+    _validateContext(context) {
+        return this._resourceManager.validateContext(context);
+    }
+    /**
+     * Enumerates target resource IDs for delta generation.
+     * If specific resource IDs are provided, uses those. Otherwise, discovers all resources
+     * from both the baseline resource manager and the delta resolver to ensure comprehensive
+     * coverage of all potential resources.
+     *
+     * @param requestedIds - Optional array of specific resource IDs to target.
+     * @param context - The validated context to use for resource discovery.
+     * @returns `Success` with array of resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    _enumerateTargetResources(requestedIds, context) {
+        if (requestedIds && requestedIds.length > 0) {
+            this._logger.info(`Using ${requestedIds.length} specified resource IDs`);
+            // Validate the requested IDs
+            const validatedIds = [];
+            const errors = new ts_utils_1.MessageAggregator();
+            for (const id of requestedIds) {
+                const validationResult = this._resourceManager.getBuiltResource(id);
+                if (validationResult.isSuccess()) {
+                    validatedIds.push(id);
+                }
+                else {
+                    errors.addMessage(`Invalid resource ID "${id}": ${validationResult.message}`);
+                }
+            }
+            if (errors.hasMessages) {
+                return (0, ts_utils_1.fail)(errors.toString());
+            }
+            return (0, ts_utils_1.succeed)(validatedIds);
+        }
+        // Discover resources from both baseline and delta resolvers to ensure comprehensive coverage
+        this._logger.info('Discovering resources from both baseline and delta resolvers');
+        return this._discoverAllResourceIds().onSuccess((allResourceIds) => {
+            this._logger.info(`Discovered ${allResourceIds.length} unique resources across both resolvers`);
+            return (0, ts_utils_1.succeed)(allResourceIds);
+        });
+    }
+    /**
+     * Discovers all unique resource IDs from both baseline and delta resolvers.
+     * Creates a union of resource IDs from the baseline resource manager and delta resolver
+     * to ensure comprehensive coverage of all resources.
+     *
+     * @returns `Success` with array of unique resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    _discoverAllResourceIds() {
+        // Get resource IDs from baseline resource manager
+        return this._resourceManager.getAllBuiltResources().onSuccess((baselineResources) => {
+            const baselineResourceIds = baselineResources.map((r) => r.id);
+            this._logger.detail(`Found ${baselineResourceIds.length} resources in baseline`);
+            // Get resource IDs from delta resolver using the public interface
+            const deltaResourceIds = this._deltaResolver.resourceIds;
+            this._logger.detail(`Found ${deltaResourceIds.length} resources in delta`);
+            // Create a union of resource IDs from both sources
+            const allResourceIds = new Set();
+            // Add baseline resource IDs
+            baselineResourceIds.forEach((id) => {
+                allResourceIds.add(id);
+            });
+            // Add delta resource IDs
+            deltaResourceIds.forEach((id) => {
+                allResourceIds.add(id);
+            });
+            const uniqueResourceIds = Array.from(allResourceIds);
+            this._logger.detail(`Created union of ${uniqueResourceIds.length} unique resource IDs`);
+            return (0, ts_utils_1.succeed)(uniqueResourceIds);
+        });
+    }
+    /**
+     * Creates a clone of the resource manager for delta operations.
+     * @returns `Success` with the cloned resource manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    _cloneResourceManager() {
+        this._logger.info('Cloning resource manager');
+        return this._resourceManager.clone();
+    }
+    /**
+     * Generates deltas for the specified resources and adds them to the cloned manager.
+     *
+     * @param clonedManager - The cloned resource manager to update.
+     * @param resourceIds - Array of resource IDs to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the updated manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    _generateDeltas(clonedManager, resourceIds, context, skipUnchanged) {
+        this._logger.info(`Generating deltas for ${resourceIds.length} resources`);
+        const errors = new ts_utils_1.MessageAggregator();
+        let processedCount = 0;
+        let changedCount = 0;
+        let newCount = 0;
+        let skippedCount = 0;
+        for (const resourceId of resourceIds) {
+            this._logger.detail(`Processing resource: ${resourceId}`);
+            const result = this._generateResourceDelta(clonedManager, resourceId, context, skipUnchanged);
+            if (result.isFailure()) {
+                errors.addMessage(`${resourceId}: ${result.message}`);
+                continue;
+            }
+            processedCount++;
+            // Track statistics based on result
+            const deltaResult = result.value;
+            if (deltaResult.type === 'skipped') {
+                skippedCount++;
+            }
+            else if (deltaResult.type === 'new') {
+                newCount++;
+            }
+            else {
+                changedCount++;
+            }
+        }
+        this._logger.info(`Processed ${processedCount} resources: ${changedCount} updated, ${newCount} new, ${skippedCount} skipped`);
+        if (errors.hasMessages) {
+            return (0, ts_utils_1.fail)(`Delta generation failed with errors:\n${errors.toString()}`);
+        }
+        return (0, ts_utils_1.succeed)(clonedManager);
+    }
+    /**
+     * Generates a delta for a single resource and adds appropriate candidates to the manager.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the resource delta result if successful, `Failure` otherwise.
+     * @internal
+     */
+    _generateResourceDelta(manager, resourceId, context, skipUnchanged) {
+        // Resolve values from both resolvers
+        const baselineResult = this._baselineResolver.resolveComposedResourceValue(resourceId);
+        const deltaResult = this._deltaResolver.resolveComposedResourceValue(resourceId);
+        const baselineExists = baselineResult.isSuccess();
+        const deltaExists = deltaResult.isSuccess();
+        if (deltaExists && !baselineExists) {
+            // New resource - exists in delta but not in baseline
+            this._logger.detail(`${resourceId}: New resource detected (exists in delta only)`);
+            return this._createNewResourceCandidate(manager, resourceId, deltaResult.value, context).onSuccess(() => (0, ts_utils_1.succeed)({ type: 'new', resourceId }));
+        }
+        if (baselineExists && !deltaExists) {
+            // Baseline-only resource - exists in baseline but not in delta (potential deletion)
+            // For now, skip these resources since delete merge method is not yet implemented
+            // TODO: When 'delete' merge method is available, create deletion candidates here
+            this._logger.detail(`${resourceId}: Baseline-only resource detected, skipping (delete merge method not yet implemented)`);
+            return (0, ts_utils_1.succeed)({ type: 'skipped', resourceId });
+        }
+        if (!baselineExists && !deltaExists) {
+            // Resource doesn't exist in either resolver - this shouldn't happen due to enumeration logic
+            return (0, ts_utils_1.fail)(`Resource ${resourceId} not found in either baseline or delta resolvers`);
+        }
+        // Both resolvers have the resource - check for changes
+        // At this point, both results are successful so values are guaranteed to exist
+        const baselineValue = baselineResult.value; // Safe: baselineExists is true
+        const deltaValue = deltaResult.value; // Safe: deltaExists is true
+        // Check if values are identical
+        if (skipUnchanged && this._areValuesIdentical(baselineValue, deltaValue)) {
+            this._logger.detail(`${resourceId}: No changes detected, skipping`);
+            return (0, ts_utils_1.succeed)({ type: 'skipped', resourceId });
+        }
+        // Updated resource - compute delta and create partial/augment candidate
+        this._logger.detail(`${resourceId}: Changes detected, computing delta`);
+        return this._createDeltaCandidate(manager, resourceId, baselineValue, deltaValue, context).onSuccess(() => (0, ts_utils_1.succeed)({ type: 'updated', resourceId }));
+    }
+    /**
+     * Checks if two JSON values are identical.
+     * @param value1 - First value to compare.
+     * @param value2 - Second value to compare.
+     * @returns True if values are identical, false otherwise.
+     * @internal
+     */
+    _areValuesIdentical(value1, value2) {
+        return JSON.stringify(value1) === JSON.stringify(value2);
+    }
+    /**
+     * Creates a new resource candidate for a newly discovered resource.
+     * Uses full/replace merge method since this is a completely new resource.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the new resource.
+     * @param value - The resolved value for the new resource.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    _createNewResourceCandidate(manager, resourceId, value, context) {
+        if (!(0, ts_json_base_1.isJsonObject)(value)) {
+            return (0, ts_utils_1.fail)(`Resource value must be a JSON object, got ${typeof value}`);
+        }
+        const candidateDecl = {
+            id: resourceId,
+            json: value,
+            conditions: Object.keys(context).length > 0 ? context : undefined,
+            isPartial: false,
+            mergeMethod: 'replace',
+            resourceTypeName: 'json' // Use 'json' resource type for new JSON resources
+        };
+        const result = manager.addLooseCandidate(candidateDecl);
+        if (result.isFailure()) {
+            return (0, ts_utils_1.fail)(result.message);
+        }
+        return (0, ts_utils_1.succeed)(undefined);
+    }
+    /**
+     * Creates a delta candidate for an updated resource.
+     * Computes the difference between baseline and delta values and creates
+     * a partial/augment candidate with only the changed properties.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the updated resource.
+     * @param baselineValue - The baseline resolved value.
+     * @param deltaValue - The delta resolved value.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    _createDeltaCandidate(manager, resourceId, baselineValue, deltaValue, context) {
+        // Compute three-way diff to get only the changed properties
+        return ts_json_1.Diff.jsonThreeWayDiff(baselineValue, deltaValue).onSuccess((diff) => {
+            if (diff.identical) {
+                // This shouldn't happen if we checked for identity earlier, but be defensive
+                this._logger.warn(`${resourceId}: Diff reports identical values, skipping`);
+                return (0, ts_utils_1.succeed)(undefined);
+            }
+            // Use onlyInB (second object) which contains new/changed properties
+            const deltaChanges = diff.onlyInB;
+            if (!(0, ts_json_base_1.isJsonObject)(deltaChanges)) {
+                return (0, ts_utils_1.fail)(`Delta changes must be a JSON object, got ${typeof deltaChanges}`);
+            }
+            // TODO: Handle deletions using 'augment' merge method with null values
+            // Note: The 'delete' merge type is not yet implemented in ts-res, so we use 'augment'
+            // with null values for deletion semantics (as used in ts-res-ui-components).
+            // When the 'delete' merge type is available, this should be updated to use it.
+            const candidateDecl = {
+                id: resourceId,
+                json: deltaChanges,
+                conditions: Object.keys(context).length > 0 ? context : undefined,
+                isPartial: true,
+                mergeMethod: 'augment',
+                resourceTypeName: undefined // Will be inferred by the manager
+            };
+            const result = manager.addLooseCandidate(candidateDecl);
+            if (result.isFailure()) {
+                return (0, ts_utils_1.fail)(result.message);
+            }
+            return (0, ts_utils_1.succeed)(undefined);
+        });
+    }
+}
+exports.DeltaGenerator = DeltaGenerator;
+//# sourceMappingURL=deltaGenerator.js.map

package/lib/packlets/resources/index.d.ts

@@ -1,6 +1,7 @@
 export * from './candidateReducer';
 export * from './candidateValue';
 export * from './candidateValueCollector';
+export * from './deltaGenerator';
 export * from './resourceCandidate';
 export * from './resource';
 export * from './resourceBuilder';

package/lib/packlets/resources/index.js

@@ -38,6 +38,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./candidateReducer"), exports);
 __exportStar(require("./candidateValue"), exports);
 __exportStar(require("./candidateValueCollector"), exports);
+__exportStar(require("./deltaGenerator"), exports);
 __exportStar(require("./resourceCandidate"), exports);
 __exportStar(require("./resource"), exports);
 __exportStar(require("./resourceBuilder"), exports);

package/lib/packlets/resources/resourceManagerBuilder.d.ts

@@ -93,6 +93,10 @@ export declare class ResourceManagerBuilder implements IResourceManager<Resource
      * the {@link Resources.ResourceCandidate | resource candidates} in this manager.
      */
     get conditions(): ReadOnlyConditionCollector;
+    /**
+     * The resource IDs that this resource manager can resolve.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * A {@link Conditions.ConditionSetCollector | ConditionSetCollector} which
      * contains the {@link Conditions.ConditionSet | condition sets} used so far by

package/lib/packlets/resources/resourceManagerBuilder.js

@@ -91,6 +91,12 @@ class ResourceManagerBuilder {
     get conditions() {
         return this._conditions;
     }
+    /**
+     * The resource IDs that this resource manager can resolve.
+     */
+    get resourceIds() {
+        return Array.from(this._resources.keys()).sort();
+    }
     /**
      * A {@link Conditions.ConditionSetCollector | ConditionSetCollector} which
      * contains the {@link Conditions.ConditionSet | condition sets} used so far by

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

@@ -54,6 +54,10 @@ export declare class CompiledResourceCollection implements IResourceManager<IRes
      * contains the {@link Qualifiers.Qualifier | qualifiers} used in this collection.
      */
     get qualifiers(): IReadOnlyQualifierCollector;
+    /**
+     * The resource IDs contained in this compiled resource collection.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * A {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector} which
      * contains the {@link ResourceTypes.ResourceType | resource types} used in this collection.

package/lib/packlets/runtime/compiledResourceCollection.js

@@ -88,6 +88,12 @@ class CompiledResourceCollection {
     get qualifiers() {
         return this._qualifiers;
     }
+    /**
+     * The resource IDs contained in this compiled resource collection.
+     */
+    get resourceIds() {
+        return Array.from(this._builtResources.keys()).sort();
+    }
     /**
      * A {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector} which
      * contains the {@link ResourceTypes.ResourceType | resource types} used in this collection.

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

@@ -82,6 +82,10 @@ export interface IResourceManager<TR extends IResource = IResource> {
      * The number of resources in this resource manager.
      */
     readonly numResources: number;
+    /**
+     * The resource IDs that this resource manager can resolve.
+     */
+    readonly resourceIds: ReadonlyArray<ResourceId>;
     /**
      * The number of candidates in this resource manager.
      */

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

@@ -1,6 +1,6 @@
 import { Result } from '@fgv/ts-utils';
 import { JsonValue } from '@fgv/ts-json-base';
-import { IResourceResolver } from '../common';
+import { IResourceResolver, ResourceId } from '../common';
 import { Condition, ConditionSet } from '../conditions';
 import { AbstractDecision } from '../decisions';
 import { ReadOnlyQualifierTypeCollector } from '../qualifier-types';
@@ -91,6 +91,10 @@ export declare class ResourceResolver implements IResourceResolver {
      * The readonly qualifier collector that provides qualifier implementations.
      */
     get qualifiers(): IReadOnlyQualifierCollector;
+    /**
+     * The resource IDs that this resolver can resolve.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
      * Each entry stores the resolved {@link Runtime.IConditionMatchResult | condition match result} for

package/lib/packlets/runtime/resourceResolver.js

@@ -41,6 +41,12 @@ class ResourceResolver {
     get qualifiers() {
         return this.contextQualifierProvider.qualifiers;
     }
+    /**
+     * The resource IDs that this resolver can resolve.
+     */
+    get resourceIds() {
+        return this.resourceManager.resourceIds;
+    }
     /**
      * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
      * Each entry stores the resolved {@link Runtime.IConditionMatchResult | condition match result} for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-res",
-  "version": "5.0.1-0",
+  "version": "5.0.1-1",
   "description": "Multi-dimensional Resource Runtime",
   "main": "lib/index.js",
   "types": "dist/ts-res.d.ts",
@@ -44,16 +44,16 @@
     "@rushstack/heft-node-rig": "2.9.5",
     "@types/heft-jest": "1.0.6",
     "eslint-plugin-tsdoc": "~0.4.0",
-    "@fgv/ts-utils-jest": "5.0.1-0",
-    "@fgv/ts-extras": "5.0.1-0"
+    "@fgv/ts-utils-jest": "5.0.1-1",
+    "@fgv/ts-extras": "5.0.1-1"
   },
   "dependencies": {
     "luxon": "^3.7.2",
     "fflate": "~0.8.2",
-    "@fgv/ts-json-base": "5.0.1-0",
-    "@fgv/ts-utils": "5.0.1-0",
-    "@fgv/ts-bcp47": "5.0.1-0",
-    "@fgv/ts-json": "5.0.1-0"
+    "@fgv/ts-utils": "5.0.1-1",
+    "@fgv/ts-json-base": "5.0.1-1",
+    "@fgv/ts-json": "5.0.1-1",
+    "@fgv/ts-bcp47": "5.0.1-1"
   },
   "scripts": {
     "build": "heft build --clean",