@fgv/ts-res-browser 1.0.0

package/src/utils/filterResources.ts

@@ -0,0 +1,677 @@
+import { Result, succeed, fail } from '@fgv/ts-utils';
+import { Context, Runtime, Import, Resources } from '@fgv/ts-res';
+import { ProcessedResources, TsResSystem, createTsResSystemFromConfig } from './tsResIntegration';
+
+export interface FilterOptions {
+  partialContextMatch?: boolean;
+  enableDebugLogging?: boolean;
+  reduceQualifiers?: boolean;
+}
+
+export interface FilteredResource {
+  id: string;
+  originalCandidateCount: number;
+  filteredCandidateCount: number;
+  hasWarning: boolean;
+}
+
+export interface FilterResult {
+  success: boolean;
+  filteredResources: FilteredResource[];
+  processedResources?: ProcessedResources;
+  error?: string;
+  warnings: string[];
+}
+
+/**
+ * Creates a filtered resource manager based on partial context matching
+ */
+// Helper function for conditional debug logging
+const debugLog = (enableDebug: boolean, ...args: any[]) => {
+  if (enableDebug) {
+    console.log(...args);
+  }
+};
+
+/**
+ * Creates a filtered resource manager using the new base library filtering functionality.
+ * This is a much simpler implementation that leverages the ResourceManagerBuilder.clone() method.
+ */
+export const createFilteredResourceManagerSimple = async (
+  originalSystem: TsResSystem,
+  partialContext: Record<string, string>,
+  options: FilterOptions = { partialContextMatch: true }
+): Promise<Result<ProcessedResources>> => {
+  try {
+    const enableDebug = options.enableDebugLogging === true;
+
+    debugLog(enableDebug, '=== SIMPLE FILTER CREATION ===');
+    debugLog(enableDebug, 'Original system:', originalSystem);
+    debugLog(enableDebug, 'Partial context:', partialContext);
+
+    // Validate the original system
+    if (!originalSystem?.resourceManager) {
+      return fail('Original system or resourceManager is undefined');
+    }
+
+    // Use Result pattern chaining as recommended
+    debugLog(enableDebug, 'Validating context and cloning manager:', partialContext);
+    const cloneResult = originalSystem.resourceManager
+      .validateContext(partialContext)
+      .onSuccess((validatedContext) => {
+        debugLog(enableDebug, 'Context validated, creating clone with context:', validatedContext);
+        return originalSystem.resourceManager.clone({
+          filterForContext: validatedContext,
+          reduceQualifiers: options.reduceQualifiers
+        });
+      })
+      .onFailure((error) => {
+        debugLog(enableDebug, 'Failed to validate context or clone:', error);
+        return fail(error);
+      });
+
+    if (cloneResult.isFailure()) {
+      return fail(`Failed to create filtered resource manager: ${cloneResult.message}`);
+    }
+
+    const filteredManager = cloneResult.value;
+    debugLog(enableDebug, 'Filtered manager created:', filteredManager);
+
+    // Create new ImportManager for the filtered system
+    const newImportManagerResult = Import.ImportManager.create({
+      resources: filteredManager
+    });
+
+    if (newImportManagerResult.isFailure()) {
+      return fail(`Failed to create filtered import manager: ${newImportManagerResult.message}`);
+    }
+
+    // Create new ContextQualifierProvider for the filtered system
+    const newContextQualifierProviderResult = Runtime.ValidatingSimpleContextQualifierProvider.create({
+      qualifiers: originalSystem.qualifiers
+    });
+
+    if (newContextQualifierProviderResult.isFailure()) {
+      return fail(`Failed to create filtered context provider: ${newContextQualifierProviderResult.message}`);
+    }
+
+    // Create TsResSystem for the filtered manager
+    const filteredSystem: TsResSystem = {
+      qualifierTypes: originalSystem.qualifierTypes,
+      qualifiers: originalSystem.qualifiers,
+      resourceTypes: originalSystem.resourceTypes,
+      resourceManager: filteredManager,
+      importManager: newImportManagerResult.value,
+      contextQualifierProvider: newContextQualifierProviderResult.value
+    };
+
+    // Process the filtered system into ProcessedResources
+    const compiledResult = filteredSystem.resourceManager.getCompiledResourceCollection({
+      includeMetadata: true
+    });
+    if (compiledResult.isFailure()) {
+      return fail(`Failed to compile filtered resources: ${compiledResult.message}`);
+    }
+
+    const resolverResult = Runtime.ResourceResolver.create({
+      resourceManager: filteredSystem.resourceManager,
+      qualifierTypes: filteredSystem.qualifierTypes,
+      contextQualifierProvider: filteredSystem.contextQualifierProvider
+    });
+
+    if (resolverResult.isFailure()) {
+      return fail(`Failed to create filtered resolver: ${resolverResult.message}`);
+    }
+
+    // Create resource summary
+    const resourceIds = Array.from(filteredSystem.resourceManager.resources.keys());
+    const summary = {
+      totalResources: resourceIds.length,
+      resourceIds,
+      errorCount: 0,
+      warnings: []
+    };
+
+    const processedResources: ProcessedResources = {
+      system: filteredSystem,
+      compiledCollection: compiledResult.value,
+      resolver: resolverResult.value,
+      resourceCount: resourceIds.length,
+      summary
+    };
+
+    debugLog(enableDebug, 'Simple filtering completed successfully');
+    return succeed(processedResources);
+  } catch (error) {
+    return fail(
+      `Unexpected error during simple filtering: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+
+export const createFilteredResourceManager = async (
+  originalSystem: TsResSystem,
+  partialContext: Record<string, string>,
+  options: FilterOptions = { partialContextMatch: true }
+): Promise<Result<ProcessedResources>> => {
+  try {
+    const enableDebug = options.enableDebugLogging === true;
+
+    debugLog(enableDebug, '=== FILTER CREATION DEBUG ===');
+    debugLog(enableDebug, 'Original system:', originalSystem);
+    debugLog(enableDebug, 'Partial context:', partialContext);
+    debugLog(enableDebug, 'Options:', options);
+
+    // Validate the original system has required components
+    if (!originalSystem) {
+      return fail('Original system is undefined - ensure resources are loaded before filtering');
+    }
+
+    debugLog(enableDebug, 'System validation - qualifiers:', originalSystem.qualifiers);
+    debugLog(enableDebug, 'System validation - resourceTypes:', originalSystem.resourceTypes);
+    debugLog(enableDebug, 'System validation - resourceManager:', originalSystem.resourceManager);
+
+    if (!originalSystem.qualifiers) {
+      return fail('Original system qualifiers are undefined - system may not be properly initialized');
+    }
+
+    if (!originalSystem.resourceTypes) {
+      return fail('Original system resourceTypes are undefined - system may not be properly initialized');
+    }
+
+    if (!originalSystem.resourceManager) {
+      return fail('Original system resourceManager is undefined - system may not be properly initialized');
+    }
+
+    // Additional validation for the objects themselves
+    if (typeof originalSystem.qualifiers !== 'object') {
+      return fail(`Original system qualifiers has invalid type: ${typeof originalSystem.qualifiers}`);
+    }
+
+    if (typeof originalSystem.resourceTypes !== 'object') {
+      return fail(`Original system resourceTypes has invalid type: ${typeof originalSystem.resourceTypes}`);
+    }
+
+    // Create validated context from user input
+    debugLog(enableDebug, 'Creating validated context...');
+    debugLog(enableDebug, 'Partial context (raw):', partialContext);
+
+    // Filter out empty string values - only include qualifiers with actual values
+    const cleanedContext = Object.fromEntries(
+      Object.entries(partialContext).filter(([, value]) => value.trim() !== '')
+    );
+
+    debugLog(enableDebug, 'Cleaned context (empty strings removed):', cleanedContext);
+    debugLog(enableDebug, 'Available qualifiers:', originalSystem.qualifiers);
+
+    const contextResult = Context.Convert.validatedContextDecl.convert(cleanedContext, {
+      qualifiers: originalSystem.qualifiers
+    });
+
+    if (contextResult.isFailure()) {
+      debugLog(enableDebug, 'Context creation failed:', contextResult.message);
+      return fail(`Failed to create context: ${contextResult.message}`);
+    }
+
+    const validatedContext = contextResult.value;
+    debugLog(enableDebug, 'Validated context created:', validatedContext);
+
+    // Get filtered resource builders that match the context
+    debugLog(enableDebug, 'Getting resources for context...');
+    debugLog(enableDebug, 'Validated context:', validatedContext);
+    debugLog(enableDebug, 'Filter options:', options);
+
+    const filteredResourceBuilders = originalSystem.resourceManager.getResourcesForContext(
+      validatedContext,
+      options
+    );
+
+    debugLog(enableDebug, 'Filtered resource builders count:', filteredResourceBuilders.length);
+    debugLog(enableDebug, 'Filtered resource builders:', filteredResourceBuilders);
+
+    // Debug: Show detailed condition evaluation for each resource
+    if (enableDebug) {
+      debugLog(enableDebug, '=== DETAILED CANDIDATE FILTERING DEBUG ===');
+      const allResourceBuilders = originalSystem.resourceManager.getAllResources();
+      for (const resourceBuilder of allResourceBuilders) {
+        const builtResult = resourceBuilder.build();
+        if (builtResult.isSuccess()) {
+          const resource = builtResult.value;
+          debugLog(enableDebug, `\n--- Resource: ${resource.id} ---`);
+          debugLog(enableDebug, `Candidates: ${resource.candidates.length}`);
+
+          resource.candidates.forEach((candidate, index) => {
+            debugLog(enableDebug, `  Candidate ${index}:`);
+            if (candidate.conditions && candidate.conditions.conditions) {
+              candidate.conditions.conditions.forEach((condition, condIndex) => {
+                const canMatch = condition.canMatchPartialContext(validatedContext, options);
+                const contextMatch = condition.getContextMatch(validatedContext, options);
+                debugLog(
+                  enableDebug,
+                  `    Condition ${condIndex}: ${condition.qualifier.name}=${condition.value} (operator: ${condition.operator})`
+                );
+                debugLog(enableDebug, `      canMatchPartialContext: ${canMatch}`);
+                debugLog(enableDebug, `      contextMatch: ${contextMatch}`);
+                debugLog(
+                  enableDebug,
+                  `      qualifier in context: ${condition.qualifier.name in validatedContext}`
+                );
+                if (condition.qualifier.name in validatedContext) {
+                  debugLog(enableDebug, `      context value: ${validatedContext[condition.qualifier.name]}`);
+                }
+              });
+            } else {
+              debugLog(enableDebug, `    No conditions (default candidate)`);
+            }
+
+            const candidateCanMatch = candidate.canMatchPartialContext(validatedContext, options);
+            debugLog(enableDebug, `  -> Candidate ${index} canMatchPartialContext: ${candidateCanMatch}`);
+          });
+
+          const resourceCandidatesForContext = resourceBuilder.getCandidatesForContext(
+            validatedContext,
+            options
+          );
+          debugLog(
+            enableDebug,
+            `  -> Resource has ${resourceCandidatesForContext.length} matching candidates`
+          );
+          debugLog(
+            enableDebug,
+            `  -> Resource included in filter: ${filteredResourceBuilders.includes(resourceBuilder)}`
+          );
+        }
+      }
+    }
+
+    // Convert filtered resources to declarations with only matching candidates
+    const resourceDeclarations: ResourceJson.Json.ILooseResourceDecl[] = [];
+
+    debugLog(enableDebug, '=== CONVERTING FILTERED RESOURCES TO DECLARATIONS ===');
+    for (const resourceBuilder of filteredResourceBuilders) {
+      const builtResourceResult = resourceBuilder.build();
+      if (builtResourceResult.isFailure()) {
+        debugLog(enableDebug, `Failed to build resource: ${builtResourceResult.message}`);
+        continue;
+      }
+
+      const builtResource = builtResourceResult.value;
+      debugLog(enableDebug, `\n--- Converting Resource: ${builtResource.id} ---`);
+      debugLog(enableDebug, `Original candidates: ${builtResource.candidates.length}`);
+
+      // Filter candidates to only include those that match the context
+      const matchingCandidates = builtResource.candidates.filter((candidate) => {
+        const canMatch = candidate.canMatchPartialContext(validatedContext, options);
+        debugLog(
+          enableDebug,
+          `  Candidate with conditions ${
+            candidate.conditions?.conditions.map((c) => `${c.qualifier.name}=${c.value}`).join(', ') || 'none'
+          }: canMatch = ${canMatch}`
+        );
+        return canMatch;
+      });
+
+      debugLog(enableDebug, `Filtered to ${matchingCandidates.length} matching candidates`);
+
+      // Create a new resource declaration with only the matching candidates
+      const originalDeclaration = builtResource.toLooseResourceDecl();
+      const filteredDeclaration: ResourceJson.Json.ILooseResourceDecl = {
+        ...originalDeclaration,
+        candidates: matchingCandidates.map((candidate) => candidate.toLooseResourceCandidateDecl())
+      };
+
+      debugLog(enableDebug, `Final declaration candidates: ${filteredDeclaration.candidates?.length || 0}`);
+
+      // Debug: Check what candidates are in the final declaration
+      if (enableDebug) {
+        filteredDeclaration.candidates?.forEach((candidate, index) => {
+          debugLog(enableDebug, `  Final Declaration Candidate ${index}:`);
+          if (candidate.conditions) {
+            Object.entries(candidate.conditions).forEach(([qualifier, value]) => {
+              debugLog(enableDebug, `    Condition: ${qualifier}=${value}`);
+            });
+          } else {
+            debugLog(enableDebug, `    No conditions (default candidate)`);
+          }
+        });
+      }
+
+      resourceDeclarations.push(filteredDeclaration);
+    }
+
+    // Validate system components before creating new manager
+    if (!originalSystem.qualifiers) {
+      return fail('Original system qualifiers is undefined');
+    }
+    if (!originalSystem.resourceTypes) {
+      return fail('Original system resourceTypes is undefined');
+    }
+
+    // Create new ResourceManagerBuilder with same configuration
+    debugLog(enableDebug, 'Creating new resource manager...');
+    debugLog(enableDebug, 'Qualifiers for new manager:', originalSystem.qualifiers);
+    debugLog(enableDebug, 'ResourceTypes for new manager:', originalSystem.resourceTypes);
+
+    const newManagerResult = Resources.ResourceManagerBuilder.create({
+      qualifiers: originalSystem.qualifiers,
+      resourceTypes: originalSystem.resourceTypes
+    });
+
+    if (newManagerResult.isFailure()) {
+      debugLog(enableDebug, 'New manager creation failed:', newManagerResult.message, newManagerResult);
+      return fail(`Failed to create new manager: ${newManagerResult.message}`);
+    }
+
+    const newManager = newManagerResult.value;
+    debugLog(enableDebug, 'New manager created successfully:', newManager);
+
+    // Add each filtered resource to the new manager
+    debugLog(enableDebug, '=== ADDING RESOURCES TO NEW FILTERED MANAGER ===');
+    for (const declaration of resourceDeclarations) {
+      debugLog(
+        enableDebug,
+        `Adding resource: ${declaration.id} with ${declaration.candidates?.length || 0} candidates`
+      );
+      const addResult = newManager.addResource(declaration);
+      if (addResult.isFailure()) {
+        debugLog(enableDebug, `Failed to add resource ${declaration.id}: ${addResult.message}`);
+      } else if (enableDebug) {
+        // Verify what actually got added to the manager
+        const retrievedResult = newManager.getBuiltResource(declaration.id);
+        if (retrievedResult.isSuccess()) {
+          const retrievedResource = retrievedResult.value;
+          debugLog(
+            enableDebug,
+            `  -> Resource added successfully with ${retrievedResource.candidates.length} candidates:`
+          );
+          retrievedResource.candidates.forEach((candidate, index) => {
+            debugLog(enableDebug, `    Final Candidate ${index}:`);
+            if (candidate.conditions && candidate.conditions.conditions) {
+              candidate.conditions.conditions.forEach((condition, condIndex) => {
+                debugLog(
+                  enableDebug,
+                  `      Condition ${condIndex}: ${condition.qualifier.name}=${condition.value}`
+                );
+              });
+            } else {
+              debugLog(enableDebug, `      No conditions (default candidate)`);
+            }
+          });
+        }
+      }
+    }
+
+    // Create new ImportManager for the filtered system
+    const newImportManagerResult = Import.ImportManager.create({
+      resources: newManager
+    });
+
+    if (newImportManagerResult.isFailure()) {
+      return fail(`Failed to create filtered import manager: ${newImportManagerResult.message}`);
+    }
+
+    // Create new ContextQualifierProvider for the filtered system
+    // Validate qualifiers again before using them
+    if (!originalSystem.qualifiers) {
+      return fail('Original system qualifiers became undefined during processing');
+    }
+
+    const newContextQualifierProviderResult = Runtime.ValidatingSimpleContextQualifierProvider.create({
+      qualifiers: originalSystem.qualifiers
+    });
+
+    if (newContextQualifierProviderResult.isFailure()) {
+      return fail(`Failed to create filtered context provider: ${newContextQualifierProviderResult.message}`);
+    }
+
+    // Create TsResSystem for the filtered manager
+    const filteredSystem: TsResSystem = {
+      qualifierTypes: originalSystem.qualifierTypes,
+      qualifiers: originalSystem.qualifiers,
+      resourceTypes: originalSystem.resourceTypes,
+      resourceManager: newManager,
+      importManager: newImportManagerResult.value,
+      contextQualifierProvider: newContextQualifierProviderResult.value
+    };
+
+    // Process the filtered system into ProcessedResources
+    const compiledResult = filteredSystem.resourceManager.getCompiledResourceCollection({
+      includeMetadata: true
+    });
+    if (compiledResult.isFailure()) {
+      return fail(`Failed to compile filtered resources: ${compiledResult.message}`);
+    }
+
+    const resolverResult = Runtime.ResourceResolver.create({
+      resourceManager: filteredSystem.resourceManager,
+      qualifierTypes: filteredSystem.qualifierTypes,
+      contextQualifierProvider: filteredSystem.contextQualifierProvider
+    });
+
+    if (resolverResult.isFailure()) {
+      return fail(`Failed to create filtered resolver: ${resolverResult.message}`);
+    }
+
+    // Create resource summary
+    const resourceIds = Array.from(filteredSystem.resourceManager.resources.keys());
+    const summary = {
+      totalResources: resourceIds.length,
+      resourceIds,
+      errorCount: 0,
+      warnings: []
+    };
+
+    const processedResources: ProcessedResources = {
+      system: filteredSystem,
+      compiledCollection: compiledResult.value,
+      resolver: resolverResult.value,
+      resourceCount: resourceIds.length,
+      summary
+    };
+
+    return succeed(processedResources);
+  } catch (error) {
+    return fail(
+      `Unexpected error during filtering: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+
+/**
+ * Analyzes resources to create filter result with validation
+ */
+export const analyzeFilteredResources = (
+  originalResources: string[],
+  filteredProcessedResources: ProcessedResources | null,
+  originalProcessedResources: ProcessedResources
+): FilterResult => {
+  const warnings: string[] = [];
+  const filteredResources: FilteredResource[] = [];
+
+  if (!filteredProcessedResources) {
+    return {
+      success: false,
+      filteredResources: [],
+      error: 'Failed to create filtered resources',
+      warnings: []
+    };
+  }
+
+  const filteredResourceIds = filteredProcessedResources.summary.resourceIds || [];
+
+  // Analyze each original resource
+  for (const resourceId of originalResources) {
+    // Get original candidate count
+    const originalResourceResult =
+      originalProcessedResources.system.resourceManager.getBuiltResource(resourceId);
+    const originalCandidateCount = originalResourceResult.isSuccess()
+      ? originalResourceResult.value.candidates.length
+      : 0;
+
+    // Check if resource exists in filtered set
+    const isInFilteredSet = filteredResourceIds.includes(resourceId);
+    let filteredCandidateCount = 0;
+    let hasWarning = false;
+
+    if (isInFilteredSet) {
+      // Get filtered candidate count
+      const filteredResourceResult =
+        filteredProcessedResources.system.resourceManager.getBuiltResource(resourceId);
+      if (filteredResourceResult.isSuccess()) {
+        filteredCandidateCount = filteredResourceResult.value.candidates.length;
+        hasWarning = filteredCandidateCount === 0;
+
+        if (hasWarning) {
+          warnings.push(`Resource "${resourceId}" has no matching candidates`);
+        }
+      }
+    } else {
+      // Resource was completely filtered out
+      hasWarning = true;
+      warnings.push(`Resource "${resourceId}" was completely filtered out`);
+    }
+
+    filteredResources.push({
+      id: resourceId,
+      originalCandidateCount,
+      filteredCandidateCount,
+      hasWarning
+    });
+  }
+
+  return {
+    success: true,
+    filteredResources,
+    processedResources: filteredProcessedResources,
+    warnings
+  };
+};
+
+/**
+ * Helper to check if context has any meaningful values
+ */
+export const hasFilterValues = (context: Record<string, string>): boolean => {
+  return Object.values(context).some((value) => value.trim() !== '');
+};
+
+/**
+ * Helper to create filter display text
+ */
+export const getFilterSummary = (context: Record<string, string>): string => {
+  const setValues = Object.entries(context)
+    .filter(([, value]) => value.trim() !== '')
+    .map(([key, value]) => `${key}=${value}`);
+
+  if (setValues.length === 0) {
+    return 'No filters applied';
+  }
+
+  return `Filtering by: ${setValues.join(', ')}`;
+};
+
+/**
+ * Alternative approach: Creates a filtered resource manager by recreating the system from scratch
+ * This is more robust but potentially slower than the direct approach
+ */
+export const createFilteredResourceManagerAlternative = async (
+  originalSystem: TsResSystem,
+  partialContext: Record<string, string>,
+  options: FilterOptions = { partialContextMatch: true }
+): Promise<Result<ProcessedResources>> => {
+  const enableDebug = options.enableDebugLogging === true;
+  try {
+    // Validate inputs first
+    if (!originalSystem?.qualifiers || !originalSystem?.resourceTypes || !originalSystem?.resourceManager) {
+      return fail('Original system is missing required components');
+    }
+
+    // Create a fresh system using the original system's configuration
+    const freshSystemResult = createTsResSystemFromConfig();
+
+    if (freshSystemResult.isFailure()) {
+      return fail(`Failed to create fresh system: ${freshSystemResult.message}`);
+    }
+
+    const freshSystem = freshSystemResult.value;
+
+    // Get all resources from the original system that match the context
+    // Filter out empty string values - only include qualifiers with actual values
+    const cleanedContext = Object.fromEntries(
+      Object.entries(partialContext).filter(([, value]) => value.trim() !== '')
+    );
+
+    const contextResult = Context.Convert.validatedContextDecl.convert(cleanedContext, {
+      qualifiers: originalSystem.qualifiers
+    });
+
+    if (contextResult.isFailure()) {
+      return fail(`Failed to create context: ${contextResult.message}`);
+    }
+
+    const validatedContext = contextResult.value;
+    const filteredResourceBuilders = originalSystem.resourceManager.getResourcesForContext(
+      validatedContext,
+      options
+    );
+
+    // Add each filtered resource to the fresh system
+    for (const resourceBuilder of filteredResourceBuilders) {
+      const builtResourceResult = resourceBuilder.build();
+      if (builtResourceResult.isFailure()) {
+        debugLog(enableDebug, `Failed to build resource: ${builtResourceResult.message}`);
+        continue;
+      }
+
+      const builtResource = builtResourceResult.value;
+      const declaration = builtResource.toLooseResourceDecl();
+
+      const addResult = freshSystem.resourceManager.addResource(declaration);
+      if (addResult.isFailure()) {
+        debugLog(enableDebug, `Failed to add resource ${declaration.id}: ${addResult.message}`);
+      }
+    }
+
+    // Finalize the fresh system similar to how it's done in tsResIntegration
+    const compiledResult = freshSystem.resourceManager.getCompiledResourceCollection({
+      includeMetadata: true
+    });
+    if (compiledResult.isFailure()) {
+      return fail(`Failed to compile filtered resources: ${compiledResult.message}`);
+    }
+
+    const resolverResult = Runtime.ResourceResolver.create({
+      resourceManager: freshSystem.resourceManager,
+      qualifierTypes: freshSystem.qualifierTypes,
+      contextQualifierProvider: freshSystem.contextQualifierProvider
+    });
+
+    if (resolverResult.isFailure()) {
+      return fail(`Failed to create filtered resolver: ${resolverResult.message}`);
+    }
+
+    // Create resource summary
+    const resourceIds = Array.from(freshSystem.resourceManager.resources.keys());
+    const summary = {
+      totalResources: resourceIds.length,
+      resourceIds,
+      errorCount: 0,
+      warnings: []
+    };
+
+    const processedResources: ProcessedResources = {
+      system: freshSystem,
+      compiledCollection: compiledResult.value,
+      resolver: resolverResult.value,
+      resourceCount: resourceIds.length,
+      summary
+    };
+
+    return succeed(processedResources);
+  } catch (error) {
+    return fail(
+      `Unexpected error during alternative filtering: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};