whet 0.0.31 → 0.0.33

package/bin/Reflect.d.ts

@@ -7,6 +7,19 @@ abstract interface in an untyped manner. Use with care.
 */
 export declare class Reflect {
 	
+	/**
+	Returns the value of the field named `field` on object `o`.
+	
+	If `o` is not an object or has no field named `field`, the result is
+	null.
+	
+	If the field is defined as a property, its accessors are ignored. Refer
+	to `Reflect.getProperty` for a function supporting property accessors.
+	
+	If `field` is null, the result is unspecified.
+	*/
+	static field(o: any, field: string): any
+	
 	/**
 	Returns the fields of structure `o`.
 	

package/bin/Reflect.js

@@ -11,6 +11,25 @@ abstract interface in an untyped manner. Use with care.
 export const Reflect = Register.global("$hxClasses")["Reflect"] = 
 class Reflect {
 	
+	/**
+	Returns the value of the field named `field` on object `o`.
+	
+	If `o` is not an object or has no field named `field`, the result is
+	null.
+	
+	If the field is defined as a property, its accessors are ignored. Refer
+	to `Reflect.getProperty` for a function supporting property accessors.
+	
+	If `field` is null, the result is unspecified.
+	*/
+	static field(o, field) {
+		try {
+			return o[field];
+		}catch (_g) {
+			return null;
+		};
+	}
+	
 	/**
 	Returns the fields of structure `o`.
 	

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.31", "-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"
 
@@ -19,6 +19,7 @@ export declare class Router {
 	
 	/**
 	* Get combined hash of all sources that fit the `pattern`.
+	* Includes matched serveIds in hash to capture filter effects.
 	*/
 	getHash(pattern?: null | MinimatchType): Promise<SourceHash>
 	
@@ -27,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;
@@ -190,10 +205,12 @@ class Router extends Register.inherits() {
 	
 	/**
 	* Get combined hash of all sources that fit the `pattern`.
+	* Includes matched serveIds in hash to capture filter effects.
 	*/
 	getHash(pattern) {
 		return this.get(pattern).then(function (items) {
 			let uniqueStones = [];
+			let serveIds = [];
 			let _g = 0;
 			while (_g < items.length) {
 				let item = items[_g];
@@ -201,7 +218,17 @@ class Router extends Register.inherits() {
 				if (uniqueStones.indexOf(item.source) == -1) {
 					uniqueStones.push(item.source);
 				};
+				serveIds.push(item.serveId);
 			};
+			serveIds.sort(function (a, b) {
+				if (a < b) {
+					return -1;
+				} else if (a > b) {
+					return 1;
+				} else {
+					return 0;
+				};
+			});
 			let result = new Array(uniqueStones.length);
 			let _g1 = 0;
 			let _g2 = uniqueStones.length;
@@ -210,7 +237,16 @@ class Router extends Register.inherits() {
 				result[i] = uniqueStones[i].getHash();
 			};
 			return Promise.all(result).then(function (hashes) {
-				return SourceHash.merge(...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")));
 			});
 		});
 	}
@@ -260,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/bin/whet/stones/Server.js

@@ -7,6 +7,7 @@ import * as Http from "http"
 import {Register} from "../../genes/Register.js"
 import {Std} from "../../Std.js"
 import {Reflect as Reflect__1} from "../../Reflect.js"
+import {Lambda} from "../../Lambda.js"
 
 const $global = Register.$global
 
@@ -71,34 +72,63 @@ class Server extends Register.inherits(Stone) {
 		let _gthis = this;
 		switch (req.method) {
 			case "GET":
-				if (id.length == 0 || id.charCodeAt(id.length - 1) == 47) {
-					let id1 = id;
-					let dir = id1.substring(0, id1.lastIndexOf("/") + 1);
-					id = Path.posix.join((dir.length == 0) ? "./" : dir, "index.html");
-				} else if (Path.posix.extname(id) == "") {
-					id = "" + id + "/index.html";
+				let isDirOrNoExt = id.length == 0 || id.charCodeAt(id.length - 1) == 47 || Path.posix.extname(id) == "";
+				let queryPromise;
+				if (isDirOrNoExt) {
+					let searchPattern = id.length == 0 || id.charCodeAt(id.length - 1) == 47;
+					queryPromise = this.config.router.get((searchPattern) ? id + "**" : id + "/**");
+				} else {
+					queryPromise = Promise.resolve([]);
 				};
-				this.config.router.get(id).then(function (routeResult) {
-					let sourcePromise = (routeResult.length > 0) ? routeResult[0].get() : (_gthis.routeDynamic != null) ? _gthis.routeDynamic(id) : Promise.resolve(null);
-					return sourcePromise.then(function (source) {
-						if (source == null) {
-							res.writeHead(404, "File not found.");
+				queryPromise.then(function (dirResults) {
+					if (isDirOrNoExt && dirResults.length == 1) {
+						id = dirResults[0].serveId;
+					} else if (isDirOrNoExt) {
+						if (!req.url.substring(0, (searchIndex > 0) ? searchIndex : req.url.length).endsWith("/")) {
+							let redirectUrl = (searchIndex > 0) ? req.url.substring(0, searchIndex) + "/" + req.url.substring(searchIndex) : req.url + "/";
+							res.writeHead(301, "Moved Permanently", {"Location": redirectUrl});
 							res.end();
 							return;
 						};
-						let headers = {"Content-Type": Mime.getType(Path.posix.extname(id).toLowerCase()), "Last-Modified": new Date(source.source.ctime * 1000).toUTCString(), "Content-Length": Std.string(source.data.length), "Cache-Control": "no-store, no-cache"};
-						if (_gthis.config.headers != null) {
-							let access = _gthis.config.headers;
-							let _g_keys = Reflect__1.fields(access);
-							let _g_index = 0;
-							while (_g_index < _g_keys.length) {
-								let key = _g_keys[_g_index++];
-								headers[key] = access[key];
-							};
+						if (id.length == 0 || id.charCodeAt(id.length - 1) == 47) {
+							let id1 = id;
+							let dir = id1.substring(0, id1.lastIndexOf("/") + 1);
+							id = Path.posix.join((dir.length == 0) ? "./" : dir, "index.html");
+						} else if (Path.posix.extname(id) == "") {
+							id = "" + id + "/index.html";
 						};
-						res.writeHead(200, headers);
-						res.write(source.data, "binary");
-						res.end();
+					};
+					_gthis.config.router.get(id).then(function (routeResult) {
+						let sourcePromise = (routeResult.length > 0) ? routeResult[0].get() : (_gthis.routeDynamic != null) ? _gthis.routeDynamic(id) : Promise.resolve(null);
+						return sourcePromise.then(function (source) {
+							if (source == null) {
+								res.writeHead(404, "File not found.");
+								res.end();
+								return;
+							};
+							let headers = {"Content-Type": Mime.getType(Path.posix.extname(id).toLowerCase()), "Last-Modified": new Date(source.source.ctime * 1000).toUTCString(), "Content-Length": Std.string(source.data.length), "Cache-Control": "no-store, no-cache"};
+							if (_gthis.config.headers != null) {
+								let access = _gthis.config.headers;
+								let _g_keys = Reflect__1.fields(access);
+								let _g_index = 0;
+								while (_g_index < _g_keys.length) {
+									let key = _g_keys[_g_index++];
+									headers[key] = access[key];
+								};
+							};
+							res.writeHead(200, headers);
+							res.write(source.data, "binary");
+							res.end();
+						})["catch"](function (e) {
+							Log.log(40, ...["Server error.", {"error": e}]);
+							res.writeHead(500, "Error happened.", _gthis.config.headers);
+							if (((e) instanceof Error)) {
+								res.write(e.stack, "utf-8");
+							} else {
+								res.write(Std.string(e), "utf-8");
+							};
+							res.end();
+						});
 					})["catch"](function (e) {
 						Log.log(40, ...["Server error.", {"error": e}]);
 						res.writeHead(500, "Error happened.", _gthis.config.headers);
@@ -124,6 +154,68 @@ class Server extends Register.inherits(Stone) {
 				res.writeHead(200, this.config.headers);
 				res.end();
 				break
+			case "POST":
+				let stoneId = Path.posix.join(".", "./", ".", id);
+				let stone = Lambda.find(this.project.stones, function (s) {
+					return s.id == stoneId;
+				});
+				if (stone == null) {
+					let e = "Could not find stone with such id.";
+					Log.log(40, ...["Server error.", {"error": e}]);
+					res.writeHead(500, "Error happened.", _gthis.config.headers);
+					if (((e) instanceof Error)) {
+						res.write(e.stack, "utf-8");
+					} else {
+						res.write(Std.string(e), "utf-8");
+					};
+					res.end();
+				} else {
+					let body = "";
+					req.on("data", function (chunk) {
+						body += chunk;
+						return body;
+					});
+					req.on("end", function () {
+						let request = JSON.parse(body);
+						if (request.config != null) {
+							let _g = 0;
+							let _g1 = Reflect__1.fields(stone.config);
+							while (_g < _g1.length) {
+								let field = _g1[_g];
+								++_g;
+								stone.config[field] = Reflect__1.field(request.config, field);
+							};
+						};
+						if (request.getSource) {
+							stone.getSource().then(function (src) {
+								let resJson = {};
+								let _g = 0;
+								let _g1 = src.data;
+								while (_g < _g1.length) {
+									let data = _g1[_g];
+									++_g;
+									resJson[data.id] = data.data.toString("base64");
+								};
+								res.writeHead(200, _gthis.config.headers);
+								res.write(JSON.stringify(resJson), "utf-8");
+								res.end();
+							})["catch"](function (e) {
+								Log.log(40, ...["Server error.", {"error": e}]);
+								res.writeHead(500, "Error happened.", _gthis.config.headers);
+								if (((e) instanceof Error)) {
+									res.write(e.stack, "utf-8");
+								} else {
+									res.write(Std.string(e), "utf-8");
+								};
+								res.end();
+							});
+						} else {
+							res.writeHead(200, _gthis.config.headers);
+							res.end();
+						};
+					});
+				};
+				break
 			case "PUT":
 				let cmd = [Path.posix.join(".", "./", ".", id)];
 				let body = "";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "whet",
-    "version": "0.0.31",
+    "version": "0.0.33",
     "description": "NodeJS based assets management and project tooling library.",
     "scripts": {
         "devinit": "npx dts2hx commander pino-pretty --modular --noLibWrap",
@@ -13,7 +13,9 @@
     "files": [
         "bin"
     ],
-    "bin": "bin/whet.js",
+    "bin": {
+        "whet": "bin/whet.js"
+    },
     "main": "bin/whet.js",
     "type": "module",
     "author": "Peter Achberger",