@toolproof-core/lib 1.0.42 → 1.0.44

package/dist/lookups/lookups.d.ts

@@ -18,8 +18,6 @@ export declare const CONSTANTS: {
     readonly Cosmos: {
         readonly RoleNames: {
             readonly ErrorOutput: "ErrorOutput";
-            readonly LessThanSource: "LessThanSource";
-            readonly LessThanTarget: "LessThanTarget";
         };
     };
     readonly Names: {

package/dist/lookups/lookups.js

@@ -20,8 +20,6 @@ export const CONSTANTS = {
     Cosmos: {
         RoleNames: {
             ErrorOutput: 'ErrorOutput',
-            LessThanSource: 'LessThanSource',
-            LessThanTarget: 'LessThanTarget',
         }
     }
 };

package/dist/utils/stepExpansion.d.ts

@@ -0,0 +1,6 @@
+import type { MutableStep, MutableToolStep, MutableToolStepKey } from './mutableStrategyOverlay.js';
+export type StepExpansionOrder = {
+    branchCaseOrder?: 'when-what' | 'what-when';
+    loopCaseOrder?: 'what-when' | 'when-what';
+};
+export declare function extractToolStepsFromStep<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>>(step: TStep, order?: StepExpansionOrder): MutableToolStep<TKey>[];

package/dist/utils/stepExpansion.js

@@ -0,0 +1,32 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+export function extractToolStepsFromStep(step, order = {}) {
+    const { branchCaseOrder = 'when-what', loopCaseOrder = 'what-when', } = order;
+    if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
+        return [step];
+    }
+    if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
+        const branch = step;
+        const cases = branch.cases ?? [];
+        return cases.flatMap((stepCase) => {
+            if (branchCaseOrder === 'what-when') {
+                return [stepCase.what, stepCase.when];
+            }
+            return [stepCase.when, stepCase.what];
+        }).filter(Boolean);
+    }
+    if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
+        const loop = step;
+        if (loopCaseOrder === 'when-what') {
+            return [loop.case.when, loop.case.what].filter(Boolean);
+        }
+        return [loop.case.what, loop.case.when].filter(Boolean);
+    }
+    if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
+        const loop = step;
+        if (loopCaseOrder === 'when-what') {
+            return [loop.case.when, loop.case.what].filter(Boolean);
+        }
+        return [loop.case.what, loop.case.when].filter(Boolean);
+    }
+    return [];
+}

package/dist/utils/stepParallelization.js

@@ -1,4 +1,4 @@
-import { CONSTANTS } from '../lookups/lookups.js';
+import { extractToolStepsFromStep } from './stepExpansion.js';
 export function getIndependentThreads(steps, strategyState) {
     const getOwnerLabel = (ownerIndex) => {
         const step = steps[ownerIndex];
@@ -17,28 +17,8 @@ export function getIndependentThreads(steps, strategyState) {
         toolStepByKey.set(toolStep.toolStepKey, toolStep);
     };
     steps.forEach((step, ownerIndex) => {
-        if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
-            addToolStep(step, ownerIndex);
-            return;
-        }
-        if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-            const loop = step;
-            addToolStep(loop.case?.what, ownerIndex);
-            addToolStep(loop.case?.when, ownerIndex);
-            return;
-        }
-        if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
-            const loop = step;
-            addToolStep(loop.case?.what, ownerIndex);
-            addToolStep(loop.case?.when, ownerIndex);
-            return;
-        }
-        if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
-            const branch = step;
-            for (const stepCase of branch.cases) {
-                addToolStep(stepCase?.what, ownerIndex);
-                addToolStep(stepCase?.when, ownerIndex);
-            }
+        for (const toolStep of extractToolStepsFromStep(step, { branchCaseOrder: 'what-when' })) {
+            addToolStep(toolStep, ownerIndex);
         }
     });
     const ownerAdj = new Map();

package/dist/utils/strategyExtraction.js

@@ -1,4 +1,5 @@
 import { CONSTANTS } from '../lookups/lookups.js';
+import { extractToolStepsFromStep } from './stepExpansion.js';
 export function getInputRoleSpecEntriesFromTool(tool) {
     return Object.entries(tool.roleSpec.inputRoleValueByName);
 }
@@ -20,32 +21,9 @@ export function extractResourceTypeHandleFromRoleValue(roleValue) {
 }
 export function extractToolStepsFromStrategy(strategy) {
     const toolSteps = [];
-    const visitStep = (step) => {
-        switch (step.stepKind) {
-            case 'tool': {
-                toolSteps.push(step);
-                return;
-            }
-            case 'branch': {
-                for (const conditional of step.cases) {
-                    toolSteps.push(conditional.when, conditional.what);
-                }
-                return;
-            }
-            case 'while':
-            case 'for': {
-                toolSteps.push(step.case.when, step.case.what);
-                return;
-            }
-            default: {
-                const _exhaustive = step;
-                return _exhaustive;
-            }
-        }
-    };
     for (const threadSteps of strategy.stepsByThreadIndex) {
         for (const step of threadSteps) {
-            visitStep(step);
+            toolSteps.push(...extractToolStepsFromStep(step, { loopCaseOrder: 'when-what' }));
         }
     }
     return toolSteps;

package/dist/utils/toolFilters.d.ts

@@ -0,0 +1,36 @@
+import type { Tool, ToolHandle } from '@toolproof-core/genesis';
+export declare function isInstantiationTool(tool: Tool): boolean;
+export declare function isScalarRoleValueOnlyTool(tool: Tool): boolean;
+export declare function isResourceTypeHandleBackedRoleValueOnlyTool(tool: Tool): boolean;
+/**
+ * Returns Tools that can be used as LoopStep whatTools.
+ *
+ * A Tool is "loop-step-eligible" if:
+ * - it has exactly one input role
+ * - it has exactly one output role
+ * - the input and output roles share the same type
+ */
+export declare function getLoopStepWhatSlotEligibleToolHandles(toolMap: Map<ToolHandle, Tool>): ToolHandle[];
+/**
+ * Returns Tools that can be used as BranchStep whatTools.
+ *
+ * A Tool is "branch-step-eligible" if:
+ * - it has exactly one output role
+ * - there's also a cross-case requirement that the whatTool's output role types must be the same (this is enforced dynamically at buildtime)
+ */
+export declare function getBranchStepWhatSlotEligibleToolHandles(toolMap: Map<ToolHandle, Tool>): ToolHandle[];
+/**
+ * Returns Tools that can be used as MacroStep whenTools.
+ *
+ * A Tool is "when-slot-eligible" if:
+ * - it has exactly one output role and that output role is of type `TYPE-Boolean`
+ * - all input role types are available in strategyState at the point of execution (this is enforced dynamically at buildtime)
+ */
+export declare function getMacroStepWhenSlotEligibleToolHandles(toolMap: Map<ToolHandle, Tool>): ToolHandle[];
+type ToolFilters = {
+    instantiationOnly?: boolean;
+    scalarRoleValueOnly?: boolean;
+    resourceTypeHandleBackedRoleValueOnly?: boolean;
+};
+export declare function getFilteredToolMap(toolMap: Map<ToolHandle, Tool>, filters?: ToolFilters): Map<ToolHandle, Tool>;
+export {};

package/dist/utils/toolFilters.js

@@ -0,0 +1,107 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+import { extractResourceTypeHandleFromRoleValue } from './strategyExtraction.js';
+export function isInstantiationTool(tool) {
+    return tool.isTemplate !== true;
+}
+function isScalarRoleValue(roleValue) {
+    return roleValue.containerKind === 'scalar';
+}
+export function isScalarRoleValueOnlyTool(tool) {
+    const inputRoleValues = Object.values(tool.roleSpec.inputRoleValueByName);
+    const outputRoleValues = Object.values(tool.roleSpec.outputRoleValueByName);
+    return [...inputRoleValues, ...outputRoleValues].every(isScalarRoleValue);
+}
+export function isResourceTypeHandleBackedRoleValueOnlyTool(tool) {
+    const roleValues = [
+        ...Object.values(tool.roleSpec.inputRoleValueByName),
+        ...Object.values(tool.roleSpec.outputRoleValueByName),
+    ];
+    return roleValues.every((roleValue) => extractResourceTypeHandleFromRoleValue(roleValue) !== null);
+}
+// ATTENTION: the slot-eligibility functions below can currently handle only scalar, resourceTypeHandle-backed role values. Callers must ensure that the provided toolMaps are pre-filtered accordingly.
+/**
+ * Returns Tools that can be used as LoopStep whatTools.
+ *
+ * A Tool is "loop-step-eligible" if:
+ * - it has exactly one input role
+ * - it has exactly one output role
+ * - the input and output roles share the same type
+ */
+export function getLoopStepWhatSlotEligibleToolHandles(toolMap) {
+    const candidates = [];
+    for (const tool of toolMap.values()) {
+        const inputEntries = Object.entries(tool.roleSpec.inputRoleValueByName);
+        if (inputEntries.length !== 1)
+            continue;
+        const outputEntries = Object.entries(tool.roleSpec.outputRoleValueByName);
+        if (outputEntries.length !== 1)
+            continue;
+        const firstInputEntry = inputEntries[0];
+        if (!firstInputEntry)
+            continue;
+        const firstOutputEntry = outputEntries[0];
+        if (!firstOutputEntry)
+            continue;
+        const inputRole = firstInputEntry[1];
+        const outputRole = firstOutputEntry[1];
+        const inputType = extractResourceTypeHandleFromRoleValue(inputRole);
+        const outputType = extractResourceTypeHandleFromRoleValue(outputRole);
+        if (inputType !== outputType)
+            continue; // ATTENTION: relies on pre-filtering to resourceTypeHandle-backed role values for correctness
+        candidates.push(tool.handle);
+    }
+    return candidates;
+}
+/**
+ * Returns Tools that can be used as BranchStep whatTools.
+ *
+ * A Tool is "branch-step-eligible" if:
+ * - it has exactly one output role
+ * - there's also a cross-case requirement that the whatTool's output role types must be the same (this is enforced dynamically at buildtime)
+ */
+export function getBranchStepWhatSlotEligibleToolHandles(toolMap) {
+    const candidates = [];
+    for (const tool of toolMap.values()) {
+        const outputEntries = Object.entries(tool.roleSpec.outputRoleValueByName);
+        if (outputEntries.length !== 1)
+            continue;
+        candidates.push(tool.handle);
+    }
+    return candidates;
+}
+/**
+ * Returns Tools that can be used as MacroStep whenTools.
+ *
+ * A Tool is "when-slot-eligible" if:
+ * - it has exactly one output role and that output role is of type `TYPE-Boolean`
+ * - all input role types are available in strategyState at the point of execution (this is enforced dynamically at buildtime)
+ */
+export function getMacroStepWhenSlotEligibleToolHandles(toolMap) {
+    const candidates = [];
+    for (const tool of toolMap.values()) {
+        const outputEntries = Object.entries(tool.roleSpec.outputRoleValueByName);
+        if (outputEntries.length !== 1)
+            continue;
+        const firstOutputEntry = outputEntries[0];
+        if (!firstOutputEntry)
+            continue;
+        const outputRoleValue = firstOutputEntry[1];
+        const outputType = extractResourceTypeHandleFromRoleValue(outputRoleValue);
+        if (outputType !== CONSTANTS.Handles.ResourceTypes.TYPE_Boolean)
+            continue;
+        candidates.push(tool.handle);
+    }
+    return candidates;
+}
+export function getFilteredToolMap(toolMap, filters = {
+    instantiationOnly: true,
+    scalarRoleValueOnly: true,
+    resourceTypeHandleBackedRoleValueOnly: true,
+}) {
+    const filteredEntries = Array.from(toolMap.entries()).filter(([, tool]) => {
+        return ((!filters.instantiationOnly || isInstantiationTool(tool))
+            && (!filters.scalarRoleValueOnly || isScalarRoleValueOnlyTool(tool))
+            && (!filters.resourceTypeHandleBackedRoleValueOnly || isResourceTypeHandleBackedRoleValueOnlyTool(tool)));
+    });
+    return new Map(filteredEntries);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -39,6 +39,10 @@
       "types": "./dist/utils/stepCreation.d.ts",
       "import": "./dist/utils/stepCreation.js"
     },
+    "./step-expansion": {
+      "types": "./dist/utils/stepExpansion.d.ts",
+      "import": "./dist/utils/stepExpansion.js"
+    },
     "./tool-step-paths": {
       "types": "./dist/utils/toolStepPaths.d.ts",
       "import": "./dist/utils/toolStepPaths.js"

package/src/lookups/lookups.ts

@@ -21,8 +21,6 @@ export const CONSTANTS = {
     Cosmos: {
         RoleNames: {
             ErrorOutput: 'ErrorOutput' as const,
-            LessThanSource: 'LessThanSource' as const,
-            LessThanTarget: 'LessThanTarget' as const,
         }
     }
 } as const;

package/src/utils/stepExpansion.ts

@@ -0,0 +1,63 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+import type {
+    MutableBranchStep,
+    MutableForStep,
+    MutableStep,
+    MutableToolStep,
+    MutableToolStepKey,
+    MutableWhileStep,
+} from './mutableStrategyOverlay.js';
+
+export type StepExpansionOrder = {
+    branchCaseOrder?: 'when-what' | 'what-when';
+    loopCaseOrder?: 'what-when' | 'when-what';
+};
+
+export function extractToolStepsFromStep<
+    TKey extends string = MutableToolStepKey,
+    TStep extends MutableStep<TKey> = MutableStep<TKey>,
+>(
+    step: TStep,
+    order: StepExpansionOrder = {},
+): MutableToolStep<TKey>[] {
+    const {
+        branchCaseOrder = 'when-what',
+        loopCaseOrder = 'what-when',
+    } = order;
+
+    if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
+        return [step as MutableToolStep<TKey>];
+    }
+
+    if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
+        const branch = step as MutableBranchStep<TKey>;
+        const cases = branch.cases ?? [];
+        return cases.flatMap((stepCase) => {
+            if (branchCaseOrder === 'what-when') {
+                return [stepCase.what, stepCase.when];
+            }
+
+            return [stepCase.when, stepCase.what];
+        }).filter(Boolean) as MutableToolStep<TKey>[];
+    }
+
+    if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
+        const loop = step as MutableWhileStep<TKey>;
+        if (loopCaseOrder === 'when-what') {
+            return [loop.case.when, loop.case.what].filter(Boolean) as MutableToolStep<TKey>[];
+        }
+
+        return [loop.case.what, loop.case.when].filter(Boolean) as MutableToolStep<TKey>[];
+    }
+
+    if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
+        const loop = step as MutableForStep<TKey>;
+        if (loopCaseOrder === 'when-what') {
+            return [loop.case.when, loop.case.what].filter(Boolean) as MutableToolStep<TKey>[];
+        }
+
+        return [loop.case.what, loop.case.when].filter(Boolean) as MutableToolStep<TKey>[];
+    }
+
+    return [] as MutableToolStep<TKey>[];
+}

package/src/utils/stepParallelization.ts

@@ -1,13 +1,10 @@
 import type {
-	MutableBranchStep,
-	MutableForStep,
 	MutableStep,
 	MutableStrategyState,
 	MutableToolStep,
 	MutableToolStepKey,
-	MutableWhileStep,
 } from './mutableStrategyOverlay.js';
-import { CONSTANTS } from '../lookups/lookups.js';
+import { extractToolStepsFromStep } from './stepExpansion.js';
 
 export function getIndependentThreads<
 	TKey extends string = MutableToolStepKey,
@@ -44,31 +41,8 @@ export function getIndependentThreads<
 	};
 
 	steps.forEach((step, ownerIndex) => {
-		if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
-			addToolStep(step as MutableToolStep<TKey>, ownerIndex);
-			return;
-		}
-
-		if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-			const loop = step as MutableForStep<TKey>;
-			addToolStep(loop.case?.what, ownerIndex);
-			addToolStep(loop.case?.when, ownerIndex);
-			return;
-		}
-
-		if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
-			const loop = step as MutableWhileStep<TKey>;
-			addToolStep(loop.case?.what, ownerIndex);
-			addToolStep(loop.case?.when, ownerIndex);
-			return;
-		}
-
-		if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
-			const branch = step as MutableBranchStep<TKey>;
-			for (const stepCase of branch.cases) {
-				addToolStep(stepCase?.what, ownerIndex);
-				addToolStep(stepCase?.when, ownerIndex);
-			}
+		for (const toolStep of extractToolStepsFromStep<TKey, TStep>(step, { branchCaseOrder: 'what-when' })) {
+			addToolStep(toolStep, ownerIndex);
 		}
 	});
 

package/src/utils/strategyExtraction.ts

@@ -8,10 +8,10 @@ import type {
 } from '@toolproof-core/genesis';
 import type {
     MutableStrategy,
-    MutableStep,
     MutableToolStep
 } from './mutableStrategyOverlay.js';
 import { CONSTANTS } from '../lookups/lookups.js';
+import { extractToolStepsFromStep } from './stepExpansion.js';
 
 export type RoleSpecEntry = [RoleName, RoleValue];
 
@@ -55,33 +55,9 @@ export function extractResourceTypeHandleFromRoleValue(
 export function extractToolStepsFromStrategy(strategy: MutableStrategy): MutableToolStep[] {
     const toolSteps: MutableToolStep[] = [];
 
-    const visitStep = (step: MutableStep) => {
-        switch (step.stepKind) {
-            case 'tool': {
-                toolSteps.push(step);
-                return;
-            }
-            case 'branch': {
-                for (const conditional of step.cases) {
-                    toolSteps.push(conditional.when, conditional.what);
-                }
-                return;
-            }
-            case 'while':
-            case 'for': {
-                toolSteps.push(step.case.when, step.case.what);
-                return;
-            }
-            default: {
-                const _exhaustive: never = step;
-                return _exhaustive;
-            }
-        }
-    };
-
     for (const threadSteps of strategy.stepsByThreadIndex) {
         for (const step of threadSteps) {
-            visitStep(step);
+            toolSteps.push(...extractToolStepsFromStep(step, { loopCaseOrder: 'when-what' }));
         }
     }
 

package/src/utils/toolFilters.ts

@@ -0,0 +1,139 @@
+import type { RoleValue, Tool, ToolHandle } from '@toolproof-core/genesis';
+import { CONSTANTS } from '../lookups/lookups.js';
+import { extractResourceTypeHandleFromRoleValue } from './strategyExtraction.js';
+
+
+export function isInstantiationTool(tool: Tool): boolean {
+    return tool.isTemplate !== true;
+}
+
+function isScalarRoleValue(roleValue: RoleValue): boolean {
+    return roleValue.containerKind === 'scalar';
+}
+
+export function isScalarRoleValueOnlyTool(tool: Tool): boolean {
+    const inputRoleValues = Object.values(tool.roleSpec.inputRoleValueByName);
+    const outputRoleValues = Object.values(tool.roleSpec.outputRoleValueByName);
+
+    return [...inputRoleValues, ...outputRoleValues].every(isScalarRoleValue);
+}
+
+export function isResourceTypeHandleBackedRoleValueOnlyTool(tool: Tool): boolean {
+    const roleValues = [
+        ...Object.values(tool.roleSpec.inputRoleValueByName),
+        ...Object.values(tool.roleSpec.outputRoleValueByName),
+    ];
+
+    return roleValues.every(
+        (roleValue) => extractResourceTypeHandleFromRoleValue(roleValue) !== null
+    );
+}
+
+// ATTENTION: the slot-eligibility functions below can currently handle only scalar, resourceTypeHandle-backed role values. Callers must ensure that the provided toolMaps are pre-filtered accordingly.
+
+/**
+ * Returns Tools that can be used as LoopStep whatTools.
+ *
+ * A Tool is "loop-step-eligible" if:
+ * - it has exactly one input role
+ * - it has exactly one output role
+ * - the input and output roles share the same type
+ */
+export function getLoopStepWhatSlotEligibleToolHandles(toolMap: Map<ToolHandle, Tool>): ToolHandle[] {
+    const candidates: ToolHandle[] = [];
+
+    for (const tool of toolMap.values()) {
+
+        const inputEntries = Object.entries(tool.roleSpec.inputRoleValueByName);
+        if (inputEntries.length !== 1) continue;
+
+        const outputEntries = Object.entries(tool.roleSpec.outputRoleValueByName);
+        if (outputEntries.length !== 1) continue;
+
+        const firstInputEntry = inputEntries[0];
+        if (!firstInputEntry) continue;
+
+        const firstOutputEntry = outputEntries[0];
+        if (!firstOutputEntry) continue;
+
+        const inputRole = firstInputEntry[1];
+        const outputRole = firstOutputEntry[1];
+
+        const inputType = extractResourceTypeHandleFromRoleValue(inputRole);
+        const outputType = extractResourceTypeHandleFromRoleValue(outputRole);
+
+        if (inputType !== outputType) continue; // ATTENTION: relies on pre-filtering to resourceTypeHandle-backed role values for correctness
+
+        candidates.push(tool.handle);
+    }
+
+    return candidates;
+}
+
+/**
+ * Returns Tools that can be used as BranchStep whatTools.
+ *
+ * A Tool is "branch-step-eligible" if:
+ * - it has exactly one output role
+ * - there's also a cross-case requirement that the whatTool's output role types must be the same (this is enforced dynamically at buildtime)
+ */
+export function getBranchStepWhatSlotEligibleToolHandles(toolMap: Map<ToolHandle, Tool>): ToolHandle[] {
+    const candidates: ToolHandle[] = [];
+
+    for (const tool of toolMap.values()) {
+        const outputEntries = Object.entries(tool.roleSpec.outputRoleValueByName);
+        if (outputEntries.length !== 1) continue;
+        candidates.push(tool.handle);
+    }
+
+    return candidates;
+}
+
+/**
+ * Returns Tools that can be used as MacroStep whenTools.
+ *
+ * A Tool is "when-slot-eligible" if:
+ * - it has exactly one output role and that output role is of type `TYPE-Boolean`
+ * - all input role types are available in strategyState at the point of execution (this is enforced dynamically at buildtime)
+ */
+export function getMacroStepWhenSlotEligibleToolHandles(toolMap: Map<ToolHandle, Tool>): ToolHandle[] {
+    const candidates: ToolHandle[] = [];
+
+    for (const tool of toolMap.values()) {
+        const outputEntries = Object.entries(tool.roleSpec.outputRoleValueByName);
+        if (outputEntries.length !== 1) continue;
+        const firstOutputEntry = outputEntries[0];
+        if (!firstOutputEntry) continue;
+        const outputRoleValue = firstOutputEntry[1];
+        const outputType = extractResourceTypeHandleFromRoleValue(outputRoleValue);
+        if (outputType !== CONSTANTS.Handles.ResourceTypes.TYPE_Boolean) continue;
+        candidates.push(tool.handle);
+    }
+
+    return candidates;
+}
+
+type ToolFilters = {
+    instantiationOnly?: boolean;
+    scalarRoleValueOnly?: boolean;
+    resourceTypeHandleBackedRoleValueOnly?: boolean;
+};
+
+export function getFilteredToolMap(
+    toolMap: Map<ToolHandle, Tool>,
+    filters: ToolFilters = {
+        instantiationOnly: true,
+        scalarRoleValueOnly: true,
+        resourceTypeHandleBackedRoleValueOnly: true,
+    },
+): Map<ToolHandle, Tool> {
+    const filteredEntries = Array.from(toolMap.entries()).filter(([, tool]) => {
+        return (
+            (!filters.instantiationOnly || isInstantiationTool(tool))
+            && (!filters.scalarRoleValueOnly || isScalarRoleValueOnlyTool(tool))
+            && (!filters.resourceTypeHandleBackedRoleValueOnly || isResourceTypeHandleBackedRoleValueOnlyTool(tool))
+        );
+    });
+
+    return new Map(filteredEntries);
+}