whet 0.0.32 → 0.0.33

package/bin/haxe/Log.d.ts

@@ -0,0 +1,33 @@
+import {PosInfos} from "./PosInfos"
+
+/**
+Log primarily provides the `trace()` method, which is invoked upon a call to
+`trace()` in Haxe code.
+*/
+export declare class Log {
+	
+	/**
+	Format the output of `trace` before printing it.
+	*/
+	static formatOutput(v: any, infos: PosInfos): string
+	
+	/**
+	Outputs `v` in a platform-dependent way.
+	
+	The second parameter `infos` is injected by the compiler and contains
+	information about the position where the `trace()` call was made.
+	
+	This method can be rebound to a custom function:
+	
+	var oldTrace = haxe.Log.trace; // store old function
+	haxe.Log.trace = function(v, ?infos) {
+	// handle trace
+	}
+	...
+	haxe.Log.trace = oldTrace;
+	
+	If it is bound to null, subsequent calls to `trace()` will cause an
+	exception.
+	*/
+	static trace(v: any, infos?: null | PosInfos): void
+}

package/bin/haxe/Log.js

@@ -0,0 +1,61 @@
+import {Register} from "../genes/Register.js"
+import {Std} from "../Std.js"
+
+const $global = Register.$global
+
+/**
+Log primarily provides the `trace()` method, which is invoked upon a call to
+`trace()` in Haxe code.
+*/
+export const Log = Register.global("$hxClasses")["haxe.Log"] = 
+class Log {
+	
+	/**
+	Format the output of `trace` before printing it.
+	*/
+	static formatOutput(v, infos) {
+		let str = Std.string(v);
+		if (infos == null) {
+			return str;
+		};
+		let pstr = infos.fileName + ":" + infos.lineNumber;
+		if (infos.customParams != null) {
+			let _g = 0;
+			let _g1 = infos.customParams;
+			while (_g < _g1.length) str += ", " + Std.string(_g1[_g++]);
+		};
+		return pstr + ": " + str;
+	}
+	
+	/**
+	Outputs `v` in a platform-dependent way.
+	
+	The second parameter `infos` is injected by the compiler and contains
+	information about the position where the `trace()` call was made.
+	
+	This method can be rebound to a custom function:
+	
+	var oldTrace = haxe.Log.trace; // store old function
+	haxe.Log.trace = function(v, ?infos) {
+	// handle trace
+	}
+	...
+	haxe.Log.trace = oldTrace;
+	
+	If it is bound to null, subsequent calls to `trace()` will cause an
+	exception.
+	*/
+	static trace(v, infos) {
+		let str = Log.formatOutput(v, infos);
+		if (typeof(console) != "undefined" && console.log != null) {
+			console.log(str);
+		};
+	}
+	static get __name__() {
+		return "haxe.Log"
+	}
+	get __class__() {
+		return Log
+	}
+}
+

package/bin/whet/Source.d.ts

@@ -25,7 +25,7 @@ export declare class Source {
 }
 
 export declare class SourceData {
-	protected constructor(id: string, data: Buffer)
+	protected constructor(id: string, data: Buffer, knownHash?: null | SourceHash)
 	data: Buffer
 	
 	/**
@@ -56,6 +56,15 @@ export declare class SourceData {
 	* @return Promise<SourceData>
 	*/
 	static fromFile(id: string, path: string, pathId: string): Promise<SourceData>
+	
+	/**
+	* Read file without recomputing hash. Used when mtime validation passed.
+	* @param id Path id relative to stone that generates it.
+	* @param path Actual path relative to CWD.
+	* @param pathId Path Id relative to project.
+	* @param knownHash The hash from cache (already validated via mtime).
+	*/
+	static fromFileSkipHash(id: string, path: string, pathId: string, knownHash: SourceHash): Promise<SourceData>
 	static fromString(id: string, s: string): SourceData
 	static fromBytes(id: string, data: Buffer): SourceData
 }

package/bin/whet/Source.js

@@ -61,12 +61,12 @@ class Source extends Register.inherits() {
 
 export const SourceData = Register.global("$hxClasses")["whet.SourceData"] = 
 class SourceData extends Register.inherits() {
-	new(id, data) {
+	new(id, data, knownHash) {
 		this.filePath = null;
 		this.filePathId = null;
 		this.data = data;
 		this.id = id;
-		this.hash = SourceHash.fromBytes(data);
+		this.hash = (knownHash != null) ? knownHash : SourceHash.fromBytes(data);
 	}
 	
 	/**
@@ -130,6 +130,29 @@ class SourceData extends Register.inherits() {
 			});
 		});
 	}
+	
+	/**
+	* Read file without recomputing hash. Used when mtime validation passed.
+	* @param id Path id relative to stone that generates it.
+	* @param path Actual path relative to CWD.
+	* @param pathId Path Id relative to project.
+	* @param knownHash The hash from cache (already validated via mtime).
+	*/
+	static fromFileSkipHash(id, path, pathId, knownHash) {
+		return new Promise(function (res, rej) {
+			Fs.readFile(path, function (err, buffer) {
+				if (err != null) {
+					Log.log(50, ...["File does not exist.", {"id": id, "path": path, "error": err}]);
+					rej(err);
+				} else {
+					let source = new SourceData(id, buffer, knownHash);
+					source.filePath = path;
+					source.filePathId = pathId;
+					res(source);
+				};
+			});
+		});
+	}
 	static fromString(id, s) {
 		return SourceData.fromBytes(id, Buffer.from(s, "utf-8"));
 	}

package/bin/whet/SourceHash.js

@@ -1,5 +1,6 @@
 import {Router} from "./route/Router.js"
 import {MaybeArray_Fields_} from "./magic/MaybeArray.js"
+import {HashCache} from "./cache/HashCache.js"
 import {Utils} from "./Utils.js"
 import {Stone} from "./Stone.js"
 import {Register} from "../genes/Register.js"
@@ -25,15 +26,7 @@ class SourceHash extends Register.inherits() {
 		return this.bytes.toString("hex");
 	}
 	static fromFile(path) {
-		return new Promise(function (res, rej) {
-			Fs.readFile(path, function (err, bytes) {
-				if (err != null) {
-					rej(err);
-				} else {
-					res(SourceHash.fromBytes(bytes));
-				};
-			});
-		});
+		return HashCache.get().getFileHash(path);
 	}
 	
 	/**

package/bin/whet/Stone.d.ts

@@ -104,6 +104,17 @@ export declare class Stone<T extends StoneConfig> {
 	*/
 	list(): Promise<string[]>
 	
+	/**
+	* Optional filter describing what this Stone can produce.
+	* Used by Router to skip Stones that can't match a query.
+	* If null, Stone is assumed to potentially produce anything.
+	*
+	* This is a function (not a static value) because Stone outputs
+	* may depend on runtime config which can change externally.
+	* Override in subclasses to provide filtering optimization.
+	*/
+	getOutputFilter(): null | OutputFilter
+	
 	/**
 	* Caches this resource under supplied `path` as a single copy.
 	* @param path
@@ -159,3 +170,19 @@ export type StoneConfig = {
 }
 
 export type AnyStone = Stone<any>
+
+/**
+* Describes what file types/patterns a Stone can produce.
+* Used by Router to skip Stones that can't match a query.
+*/
+export type OutputFilter = {
+	/**
+	* File extensions this Stone can produce (without dot). Null = any.
+	* Supports compound extensions like "png.meta.json" for metadata files.
+	*/
+	extensions?: null | string[], 
+	/**
+	Glob patterns for output files. Null = matches any file with valid extension.
+	*/
+	patterns?: null | string[]
+}

package/bin/whet/Stone.js

@@ -241,6 +241,19 @@ class Stone extends Register.inherits() {
 		});
 	}
 	
+	/**
+	* Optional filter describing what this Stone can produce.
+	* Used by Router to skip Stones that can't match a query.
+	* If null, Stone is assumed to potentially produce anything.
+	*
+	* This is a function (not a static value) because Stone outputs
+	* may depend on runtime config which can change externally.
+	* Override in subclasses to provide filtering optimization.
+	*/
+	getOutputFilter() {
+		return null;
+	}
+	
 	/**
 	* Caches this resource under supplied `path` as a single copy.
 	* @param path

package/bin/whet/Whet.js

@@ -12,7 +12,7 @@ const $global = Register.$global
 export const Whet_Fields_ = Register.global("$hxClasses")["whet._Whet.Whet_Fields_"] = 
 class Whet_Fields_ {
 	static main() {
-		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.0.32", "-v, --version").allowUnknownOption(true).showSuggestionAfterError(true).option("-p, --project <file>", "project to run", "Project.mjs").option("-l, --log-level <level>", "log level, a string/number", "info").option("--no-pretty", "disable pretty logging").exitOverride();
+		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.0.33", "-v, --version").allowUnknownOption(true).showSuggestionAfterError(true).option("-p, --project <file>", "project to run", "Project.mjs").option("-l, --log-level <level>", "log level, a string/number", "info").option("--no-pretty", "disable pretty logging").exitOverride();
 		try {
 			Whet_Fields_.program.parse();
 		}catch (_g) {

package/bin/whet/cache/FileCache.d.ts

@@ -25,7 +25,9 @@ export type FileCacheValue<H, S> = {
 	files: {
 		fileHash: H, 
 		filePath: S, 
-		id: S
+		id: S, 
+		mtime?: null | number, 
+		size?: null | number
 	}[], 
 	hash: H
 }

package/bin/whet/cache/FileCache.js

@@ -1,3 +1,4 @@
+import {HashCache} from "./HashCache.js"
 import {BaseCache} from "./BaseCache.js"
 import {Utils} from "../Utils.js"
 import {SourceHash} from "../SourceHash.js"
@@ -41,7 +42,7 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 					while (_g3 < _g4.length) {
 						let file = _g4[_g3];
 						++_g3;
-						_g2.push({"fileHash": SourceHash.fromHex(file.fileHash), "filePath": file.filePath, "id": file.id});
+						_g2.push({"fileHash": SourceHash.fromHex(file.fileHash), "filePath": file.filePath, "id": file.id, "mtime": file.mtime, "size": file.size});
 					};
 					_g.push({"hash": tmp, "ctime": val1, "baseDir": val2, "files": _g2});
 				};
@@ -62,6 +63,7 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 		} else {
 			idOverride = null;
 		};
+		let _gthis = this;
 		let _g1 = [];
 		let _g2 = 0;
 		let _g3 = source.data;
@@ -69,7 +71,10 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 			let data = _g3[_g2];
 			++_g2;
 			_g1.push(data.getFilePathId(idOverride).then(function (filePath) {
-				return {"fileHash": SourceHash.fromBytes(data.data), "filePath": filePath, "id": data.id};
+				let cwdPath = Path.posix.join(".", _gthis.rootDir, ".", filePath);
+				return HashCache.getStats(cwdPath).then(function (stats) {
+					return {"fileHash": SourceHash.fromBytes(data.data), "filePath": filePath, "id": data.id, "mtime": stats.mtime, "size": stats.size};
+				});
 			}));
 		};
 		return Promise.all(_g1).then(function (files) {
@@ -100,17 +105,32 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 			++_g2;
 			_g1.push(new Promise(function (res, rej) {
 				let path = Path.posix.join(".", _gthis.rootDir, ".", file.filePath);
-				SourceData.fromFile(file.id, path, file.filePath).then(function (sourceData) {
-					if (sourceData == null || !stone.ignoreFileHash && !SourceHash.equals(sourceData.hash, file.fileHash)) {
-						rej("Invalid.");
-					} else {
-						res(sourceData);
+				Fs.stat(path, function (statErr, stats) {
+					if (statErr != null) {
+						if (((statErr) instanceof Error) && statErr.code == "ENOENT") {
+							rej("Invalid.");
+						} else {
+							rej(statErr);
+						};
+						return;
 					};
-				}, function (err) {
-					if (((err) instanceof Error) && err.code == "ENOENT") {
-						rej("Invalid.");
+					let mtimeMatch = file.mtime != null && stats.mtimeMs == file.mtime && (stats.size | 0) == file.size;
+					if (mtimeMatch && !stone.ignoreFileHash) {
+						SourceData.fromFileSkipHash(file.id, path, file.filePath, file.fileHash).then(res, rej);
 					} else {
-						rej(err);
+						SourceData.fromFile(file.id, path, file.filePath).then(function (sourceData) {
+							if (sourceData == null || !stone.ignoreFileHash && !SourceHash.equals(sourceData.hash, file.fileHash)) {
+								rej("Invalid.");
+							} else {
+								res(sourceData);
+							};
+						}, function (err) {
+							if (((err) instanceof Error) && err.code == "ENOENT") {
+								rej("Invalid.");
+							} else {
+								rej(err);
+							};
+						});
 					};
 				});
 			}));
@@ -236,7 +256,7 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 					while (_g3 < _g4.length) {
 						let file = _g4[_g3];
 						++_g3;
-						_g2.push({"fileHash": SourceHash.toHex(file.fileHash), "filePath": Path.posix.join(".", "./", ".", file.filePath), "id": Path.posix.join(".", "./", ".", file.id)});
+						_g2.push({"fileHash": SourceHash.toHex(file.fileHash), "filePath": Path.posix.join(".", "./", ".", file.filePath), "id": Path.posix.join(".", "./", ".", file.id), "mtime": file.mtime, "size": file.size});
 					};
 					_g.push({"hash": tmp, "ctime": val1, "ctimePretty": tmp1, "baseDir": tmp2, "files": _g2});
 				};

package/bin/whet/cache/HashCache.d.ts

@@ -0,0 +1,36 @@
+import {SourceHash} from "../SourceHash"
+import {Map as Map__1} from "../../Map"
+
+/**
+* In-memory cache for file hashes based on mtime+size.
+* Avoids re-reading and re-hashing file contents when files haven't changed.
+*/
+export declare class HashCache {
+	protected constructor()
+	protected cache: Map__1<string, CachedHash>
+	
+	/**
+	* Get hash for file, using cache if mtime/size match.
+	* Returns cached hash or computes new one.
+	*/
+	getFileHash(path: string): Promise<SourceHash>
+	protected static instance: HashCache
+	static get(): HashCache
+	
+	/**
+	* Get file stats (mtime and size) for a path.
+	* Useful for storing alongside cache entries.
+	*/
+	static getStats(path: string): Promise<FileStats>
+}
+
+export type CachedHash = {
+	hash: string, 
+	mtime: number, 
+	size: number
+}
+
+export type FileStats = {
+	mtime: number, 
+	size: number
+}

package/bin/whet/cache/HashCache.js

@@ -0,0 +1,79 @@
+import {SourceHash} from "../SourceHash.js"
+import {StringMap} from "../../haxe/ds/StringMap.js"
+import {Register} from "../../genes/Register.js"
+import * as Fs from "fs"
+
+const $global = Register.$global
+
+/**
+* In-memory cache for file hashes based on mtime+size.
+* Avoids re-reading and re-hashing file contents when files haven't changed.
+*/
+export const HashCache = Register.global("$hxClasses")["whet.cache.HashCache"] = 
+class HashCache extends Register.inherits() {
+	new() {
+		this.cache = new StringMap();
+	}
+	
+	/**
+	* Get hash for file, using cache if mtime/size match.
+	* Returns cached hash or computes new one.
+	*/
+	getFileHash(path) {
+		let _gthis = this;
+		return new Promise(function (res, rej) {
+			Fs.stat(path, function (err, stats) {
+				if (err != null) {
+					rej(err);
+					return;
+				};
+				let cached = _gthis.cache.inst.get(path);
+				let mtimeMs = stats.mtimeMs;
+				if (cached != null && cached.mtime == mtimeMs && cached.size == (stats.size | 0)) {
+					res(SourceHash.fromHex(cached.hash));
+					return;
+				};
+				Fs.readFile(path, function (err, data) {
+					if (err != null) {
+						rej(err);
+						return;
+					};
+					let hash = SourceHash.fromBytes(data);
+					let this1 = _gthis.cache;
+					let value = {"mtime": mtimeMs, "size": stats.size | 0, "hash": SourceHash.toHex(hash)};
+					this1.inst.set(path, value);
+					res(hash);
+				});
+			});
+		});
+	}
+	static get() {
+		if (HashCache.instance == null) {
+			HashCache.instance = new HashCache();
+		};
+		return HashCache.instance;
+	}
+	
+	/**
+	* Get file stats (mtime and size) for a path.
+	* Useful for storing alongside cache entries.
+	*/
+	static getStats(path) {
+		return new Promise(function (res, rej) {
+			Fs.stat(path, function (err, stats) {
+				if (err != null) {
+					rej(err);
+				} else {
+					res({"mtime": stats.mtimeMs, "size": stats.size | 0});
+				};
+			});
+		});
+	}
+	static get __name__() {
+		return "whet.cache.HashCache"
+	}
+	get __class__() {
+		return HashCache
+	}
+}
+

package/bin/whet/route/OutputFilterMatcher.d.ts

@@ -0,0 +1,32 @@
+import {OutputFilter} from "../Stone"
+
+/**
+* Utility for matching queries against Stone output filters.
+* Enables skipping entire Stone subtrees when their outputs can't match a query.
+*/
+export declare class OutputFilterMatcher {
+	
+	/**
+	* Check if a query could possibly match a Stone's output filter.
+	* Returns true if the Stone should be enumerated, false if it can be skipped.
+	*
+	* @param query The search pattern (often a specific file path)
+	* @param filter The Stone's output filter (null = matches anything)
+	* @param queryIsPattern True if query contains wildcards
+	*/
+	static couldMatch(query: string, filter: null | OutputFilter, queryIsPattern: boolean): boolean
+	
+	/**
+	* Extract extension from path, supporting compound extensions.
+	* "title.png" → "png"
+	* "title.png.meta.json" → "png.meta.json"
+	* Returns null if no extension or contains wildcard.
+	*/
+	protected static getExtension(path: string): null | string
+	
+	/**
+	* Check if query extension matches any filter extension.
+	* Handles compound extensions: query "png.meta.json" matches filter "json" or "meta.json" or "png.meta.json"
+	*/
+	protected static extensionMatches(queryExt: string, filterExts: string[]): boolean
+}

package/bin/whet/route/OutputFilterMatcher.js

@@ -0,0 +1,83 @@
+import Minimatch from "minimatch"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+* Utility for matching queries against Stone output filters.
+* Enables skipping entire Stone subtrees when their outputs can't match a query.
+*/
+export const OutputFilterMatcher = Register.global("$hxClasses")["whet.route.OutputFilterMatcher"] = 
+class OutputFilterMatcher {
+	
+	/**
+	* Check if a query could possibly match a Stone's output filter.
+	* Returns true if the Stone should be enumerated, false if it can be skipped.
+	*
+	* @param query The search pattern (often a specific file path)
+	* @param filter The Stone's output filter (null = matches anything)
+	* @param queryIsPattern True if query contains wildcards
+	*/
+	static couldMatch(query, filter, queryIsPattern) {
+		if (filter == null) {
+			return true;
+		};
+		if (filter.extensions != null) {
+			let queryExt = OutputFilterMatcher.getExtension(query);
+			if (queryExt != null && !OutputFilterMatcher.extensionMatches(queryExt, filter.extensions)) {
+				return false;
+			};
+		};
+		if (!queryIsPattern && filter.patterns != null) {
+			let _g = 0;
+			let _g1 = filter.patterns;
+			while (_g < _g1.length) if (new Minimatch.Minimatch("**/" + _g1[_g++], null).match(query)) {
+				return true;
+			};
+			return false;
+		};
+		return true;
+	}
+	
+	/**
+	* Extract extension from path, supporting compound extensions.
+	* "title.png" → "png"
+	* "title.png.meta.json" → "png.meta.json"
+	* Returns null if no extension or contains wildcard.
+	*/
+	static getExtension(path) {
+		let name = path.substring(path.lastIndexOf("/") + 1);
+		let firstDot = name.indexOf(".");
+		if (firstDot == -1 || firstDot == name.length - 1) {
+			return null;
+		};
+		let ext = name.substring(firstDot + 1).toLowerCase();
+		if (ext.indexOf("*") != -1) {
+			return null;
+		};
+		return ext;
+	}
+	
+	/**
+	* Check if query extension matches any filter extension.
+	* Handles compound extensions: query "png.meta.json" matches filter "json" or "meta.json" or "png.meta.json"
+	*/
+	static extensionMatches(queryExt, filterExts) {
+		let _g = 0;
+		while (_g < filterExts.length) {
+			let filterExt = filterExts[_g];
+			++_g;
+			if (queryExt == filterExt || queryExt.endsWith("." + filterExt)) {
+				return true;
+			};
+		};
+		return false;
+	}
+	static get __name__() {
+		return "whet.route.OutputFilterMatcher"
+	}
+	get __class__() {
+		return OutputFilterMatcher
+	}
+}
+

package/bin/whet/route/Router.d.ts

@@ -1,7 +1,7 @@
 import {RouteResult} from "./RouteResult"
 import {RoutePathType} from "../magic/RoutePathType"
 import {MinimatchType} from "../magic/MinimatchType"
-import {AnyStone} from "../Stone"
+import {OutputFilter, AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
 import Minimatch from "minimatch"
 
@@ -28,6 +28,12 @@ export declare class Router {
 	*/
 	saveInto(pattern: MinimatchType, saveInto: string, clearFirst?: boolean): Promise<any>
 	listContents(pattern?: null | MinimatchType): Promise<string>
+	
+	/**
+	* Compute combined output filter from all routes.
+	* Must be dynamic (not cached) because Stone configs can change externally.
+	*/
+	getOutputFilter(): null | OutputFilter
 }
 
 export type Filter = {

package/bin/whet/route/Router.js

@@ -1,4 +1,5 @@
 import {RouteResult} from "./RouteResult.js"
+import {OutputFilterMatcher} from "./OutputFilterMatcher.js"
 import {RoutePathType_Fields_} from "../magic/RoutePathType.js"
 import {MinimatchType_Fields_} from "../magic/MinimatchType.js"
 import {Utils} from "../Utils.js"
@@ -31,6 +32,8 @@ class Router extends Register.inherits() {
 		let _gthis = this;
 		return new Promise(function (res, rej) {
 			let allRouteProms = [];
+			let pattern = (mainFilters.length > 0 && mainFilters[0].filter != null) ? mainFilters[0].filter.pattern : null;
+			let queryIsPattern = pattern != null && (pattern.indexOf("*") != -1 || pattern.indexOf("?") != -1);
 			let _g = 0;
 			let _g1 = _gthis.routes;
 			while (_g < _g1.length) {
@@ -127,6 +130,18 @@ class Router extends Register.inherits() {
 					};
 					routeFilters.push({"pathSoFar": [], "filter": f, "inProgress": true, "remDirs": []});
 				};
+				let outputFilter = null;
+				if (((route.source) instanceof Stone)) {
+					outputFilter = route.source.getOutputFilter();
+				} else if (((route.source) instanceof Router)) {
+					outputFilter = route.source.getOutputFilter();
+				};
+				if (outputFilter != null) {
+					let queryPattern = (routeFilters.length > 0 && routeFilters[0].filter != null) ? routeFilters[0].filter.pattern : null;
+					if (queryPattern != null && !OutputFilterMatcher.couldMatch(queryPattern, outputFilter, queryIsPattern)) {
+						continue;
+					};
+				};
 				let prom;
 				if (((route.source) instanceof Stone)) {
 					let stone = route.source;
@@ -222,6 +237,15 @@ class Router extends Register.inherits() {
 				result[i] = uniqueStones[i].getHash();
 			};
 			return Promise.all(result).then(function (hashes) {
+				hashes.sort(function (a, b) {
+					if (a.toString() < b.toString()) {
+						return -1;
+					} else if (a.toString() > b.toString()) {
+						return 1;
+					} else {
+						return 0;
+					};
+				});
 				return SourceHash.merge(...hashes).add(SourceHash.fromString(serveIds.join("\n")));
 			});
 		});
@@ -272,6 +296,55 @@ class Router extends Register.inherits() {
 			return result.join("\n");
 		});
 	}
+	
+	/**
+	* Compute combined output filter from all routes.
+	* Must be dynamic (not cached) because Stone configs can change externally.
+	*/
+	getOutputFilter() {
+		let allExtensions = new Array();
+		let allPatterns = new Array();
+		let hasUnfiltered = false;
+		let _g = 0;
+		let _g1 = this.routes;
+		while (_g < _g1.length) {
+			let route = _g1[_g];
+			++_g;
+			let childFilter = null;
+			if (((route.source) instanceof Stone)) {
+				childFilter = route.source.getOutputFilter();
+			} else if (((route.source) instanceof Router)) {
+				childFilter = route.source.getOutputFilter();
+			};
+			if (childFilter == null) {
+				hasUnfiltered = true;
+				break;
+			};
+			if (childFilter.extensions != null) {
+				let _g = 0;
+				let _g1 = childFilter.extensions;
+				while (_g < _g1.length) {
+					let ext = _g1[_g];
+					++_g;
+					if (allExtensions.indexOf(ext) == -1) {
+						allExtensions.push(ext);
+					};
+				};
+			};
+			if (childFilter.patterns != null) {
+				let _g = 0;
+				let _g1 = childFilter.patterns;
+				while (_g < _g1.length) {
+					let prefixed = Path.posix.join(route.routeUnder, _g1[_g++]);
+					allPatterns.push(prefixed);
+				};
+			};
+		};
+		if (hasUnfiltered) {
+			return null;
+		};
+		return {"extensions": (allExtensions.length > 0) ? allExtensions : null, "patterns": (allPatterns.length > 0) ? allPatterns : null};
+	}
 	static get __name__() {
 		return "whet.route.Router"
 	}

package/bin/whet/stones/Files.d.ts

@@ -9,6 +9,7 @@ import {Project} from "../Project"
 export declare class Files extends Stone<FilesConfig> {
 	constructor(config: FilesConfig)
 	protected initConfig(): void
+	protected generateHash(): Promise<SourceHash>
 	list(): Promise<string[]>
 	protected generate(hash: SourceHash): Promise<SourceData[]>
 	protected walk<T>(onFile: ((arg0: string) => T), onDirFile: ((arg0: string, arg1: string) => T)): Promise<T[]>

package/bin/whet/stones/Files.js

@@ -1,7 +1,9 @@
 import {MaybeArray_Fields_} from "../magic/MaybeArray.js"
+import {HashCache} from "../cache/HashCache.js"
 import {Utils} from "../Utils.js"
 import {Stone} from "../Stone.js"
 import {IdUtils, RootDir} from "../SourceId.js"
+import {SourceHash} from "../SourceHash.js"
 import {SourceData} from "../Source.js"
 import {Register} from "../../genes/Register.js"
 
@@ -15,6 +17,35 @@ class Files extends Register.inherits(() => Stone, true) {
 	initConfig() {
 		this.config.recursive = (this.config.recursive != null) ? this.config.recursive : true;
 	}
+	generateHash() {
+		let hashCache = HashCache.get();
+		let onDirFile = function (dir, dirFile) {
+			return hashCache.getFileHash(dirFile);
+		};
+		let files = [];
+		let dirs = [];
+		let _g = 0;
+		let _g1 = MaybeArray_Fields_.makeArray(this.config.paths);
+		while (_g < _g1.length) {
+			let path = _g1[_g];
+			++_g;
+			if (path.length == 0 || path.charCodeAt(path.length - 1) == 47) {
+				dirs.push(Utils.listDirectoryFiles(this.cwdPath(path), this.config.recursive).then(function (arr) {
+					let _g = 0;
+					while (_g < arr.length) files.push(onDirFile(path, arr[_g++]));
+				}));
+			} else {
+				files.push(hashCache.getFileHash(this.cwdPath(path)));
+			};
+		};
+		return Promise.all(dirs).then(function (_) {
+			return files;
+		}).then(function (hashProms) {
+			return Promise.all(hashProms);
+		}).then(function (hashes) {
+			return SourceHash.merge(...hashes);
+		});
+	}
 	list() {
 		let _gthis = this;
 		let onDirFile = function (dir, dirFile) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "whet",
-    "version": "0.0.32",
+    "version": "0.0.33",
     "description": "NodeJS based assets management and project tooling library.",
     "scripts": {
         "devinit": "npx dts2hx commander pino-pretty --modular --noLibWrap",