whet 0.2.0 → 0.5.0

package/bin/genes/util/EsMap.d.ts

@@ -6,6 +6,7 @@ export declare class EsMap<K, V> {
 	protected inst: Map<K, V>
 	set(key: K, value: V): void
 	get(key: K): null | V
+	remove(key: K): boolean
 	exists(key: K): boolean
 	keys(): Iterator<K>
 	protected static adaptIterator<T>(from: Iterator__1<T>): Iterator<T>

package/bin/genes/util/EsMap.js

@@ -13,6 +13,9 @@ class EsMap extends Register.inherits() {
 	get(key) {
 		return this.inst.get(key);
 	}
+	remove(key) {
+		return this.inst["delete"](key);
+	}
 	exists(key) {
 		return this.inst.has(key);
 	}

package/bin/haxe/Constraints.d.ts

@@ -4,5 +4,6 @@ export declare interface IMap<K, V> {
 	get(k: K): null | V
 	set(k: K, v: V): void
 	exists(k: K): boolean
+	remove(k: K): boolean
 	keys(): Iterator<K>
 }

package/bin/haxe/Exception.d.ts

@@ -55,6 +55,7 @@ export declare class Exception extends Error {
 	protected __skipStack: number
 	protected __nativeException: any
 	protected __previousException: null | Exception
+	protected unwrap(): any
 	
 	/**
 	Returns exception message.

package/bin/haxe/Exception.js

@@ -52,6 +52,9 @@ class Exception extends Register.inherits(() => Error, true) {
 		this.__previousException = previous;
 		this.__nativeException = ($native != null) ? $native : this;
 	}
+	unwrap() {
+		return this.__nativeException;
+	}
 	
 	/**
 	Returns exception message.

package/bin/haxe/ValueException.d.ts

@@ -21,4 +21,13 @@ export declare class ValueException extends Exception {
 	Thrown value.
 	*/
 	value: any
+	
+	/**
+	Extract an originally thrown value.
+	
+	This method must return the same value on subsequent calls.
+	Used internally for catching non-native exceptions.
+	Do _not_ override unless you know what you are doing.
+	*/
+	protected unwrap(): any
 }

package/bin/haxe/ValueException.js

@@ -23,6 +23,17 @@ class ValueException extends Register.inherits(() => Exception, true) {
 		super[Register.new](String(value), previous, $native);
 		this.value = value;
 	}
+	
+	/**
+	Extract an originally thrown value.
+	
+	This method must return the same value on subsequent calls.
+	Used internally for catching non-native exceptions.
+	Do _not_ override unless you know what you are doing.
+	*/
+	unwrap() {
+		return this.value;
+	}
 	static get __name__() {
 		return "haxe.ValueException"
 	}

package/bin/whet/Log.js

@@ -89,6 +89,9 @@ class LogLevel {
 			case "info":
 				return 30;
 				break
+			case "silent":
+				return 100;
+				break
 			case "trace":
 				return 10;
 				break

package/bin/whet/Project.d.ts

@@ -24,6 +24,11 @@ export declare class Project {
 	config: any
 	protected options: Option[]
 	getStone(id: string): null | AnyStone
+	
+	/**
+	Remove a stone from the project. Does not clear cache — use cache.clearStone() separately if needed.
+	*/
+	removeStone(stone: AnyStone): boolean
 	describeStones(): StoneDescription[]
 	listStoneOutputs(id: string): Promise<null | string[]>
 	getStoneSource(id: string, sourceId?: null | string): Promise<null | Source>

package/bin/whet/Project.js

@@ -75,6 +75,18 @@ class Project extends Register.inherits() {
 		};
 		return null;
 	}
+	
+	/**
+	Remove a stone from the project. Does not clear cache — use cache.clearStone() separately if needed.
+	*/
+	removeStone(stone) {
+		let idx = this.stones.indexOf(stone);
+		if (idx == -1) {
+			return false;
+		};
+		this.stones.splice(idx, 1);
+		return true;
+	}
 	describeStones() {
 		let _g = [];
 		let _g1 = 0;

package/bin/whet/Stone.d.ts

@@ -55,6 +55,7 @@ export declare class Stone<T extends StoneConfig> {
 	* Hashes of dependency stones (see `config.dependencies`) will be added to the hash.
 	*/
 	getHash(): Promise<SourceHash>
+	protected _computeHash(): Promise<SourceHash>
 	
 	/**
 	* **Do not override.**
@@ -120,6 +121,52 @@ export declare class Stone<T extends StoneConfig> {
 	*/
 	protected generatePartial(sourceId: string, hash: SourceHash): Promise<null | SourceData[]>
 	
+	/**
+	* Optional override: compute expensive shared state once and reuse it across all
+	* `list()` / `generatePartial()` calls within a generation batch. Without this, work like
+	* enumerating inputs, resolving pipelines, or building lookup maps gets repeated once per output.
+	*
+	* Override to do the upfront work; call `getContext()` (not this) from `list()`/`generatePartial()`
+	* to read it. The result is cached (see `getContext` for the caching rules). The returned object
+	* is held by reference and never serialized — Maps, class instances, and closures are fine.
+	*
+	* **Constraint**: `generateContext` must not call back into this *same* stone's `getSource()` /
+	* `getPartialSource()` — it runs inside this stone's `acquire()` lock and would deadlock. Reading
+	* from *other* stones (dependencies) is fine.
+	*/
+	protected generateContext(hash: SourceHash): Promise<any>
+	
+	/**
+	Instance-level context cache, keyed by a stable (non-null) hash. See getContext.
+	*/
+	protected _contextPromise: null | {
+		hash: SourceHash, 
+		promise: Promise<any>
+	}
+	
+	/**
+	* **Do not override** (override `generateContext` instead). Returns the shared context,
+	* computing it via `generateContext` at most once per key. Callable from `list()`,
+	* `generatePartial()`, or `generateHash()`.
+	*
+	* Caching:
+	* - With a stable (non-null) hash, the resolved Promise is cached on the stone instance keyed by
+	*   that hash, so it is reused across separate `getSource()`/`getPartialSource()` calls — even
+	*   across builds — as long as the hash matches. A changed hash recomputes.
+	* - With a null hash (a stone without `generateHash()`), there is no stable key, so the context is
+	*   scoped to the current request via `MemoContext` instead of the instance. This still shares it
+	*   across the `Promise.all` batch in the default `generate()`, but avoids holding stale state
+	*   across builds.
+	*
+	* In both cases the *Promise* (not the resolved value) is cached, so concurrent callers from the
+	* same batch share one in-flight computation rather than racing to start their own.
+	*
+	* @param hash Pass the hash when you already have it (from `generatePartial`); omit it elsewhere
+	* (e.g. `list()`) and it is derived via `finalMaybeHash()` without forcing generation.
+	*/
+	protected getContext(hash?: null | SourceHash): Promise<any>
+	protected _contextForHash(hash: null | SourceHash): Promise<any>
+	
 	/**
 	* Get source for a single output by sourceId.
 	* If the stone implements generatePartial(), generates just the requested output.
@@ -127,6 +174,7 @@ export declare class Stone<T extends StoneConfig> {
 	* Uses the same cache as getSource() — partial and full share the pool.
 	*/
 	getPartialSource(sourceId: string): Promise<null | Source>
+	protected _computePartialSource(sourceId: string): Promise<null | Source>
 	
 	/**
 	* Called by cache infrastructure. Generates partial source directly,

package/bin/whet/Stone.js

@@ -1,5 +1,6 @@
 import {StoneId_Fields_} from "./magic/StoneId.js"
 import {MaybeArray_Fields_} from "./magic/MaybeArray.js"
+import {MemoContext} from "./cache/MemoContext.js"
 import {CacheStrategy, CacheDurability} from "./cache/Cache.js"
 import {Utils} from "./Utils.js"
 import {RootDir} from "./SourceId.js"
@@ -15,6 +16,7 @@ const $global = Register.$global
 export const Stone = Register.global("$hxClasses")["whet.Stone"] = 
 class Stone extends Register.inherits() {
 	[Register.new](config) {
+		this._contextPromise = null;
 		this.locked = false;
 		this.lockQueue = [];
 		this.ignoreFileHash = false;
@@ -116,7 +118,24 @@ class Stone extends Register.inherits() {
 	*/
 	getSource() {
 		Log.log(20, ...["Getting source.", {"stone": this}]);
-		return this.project.cache.getSource(this);
+		let ctx = MemoContext.als.getStore();
+		if (ctx != null) {
+			let cached = ctx.sources.get(this);
+			if (cached != null) {
+				Log.log(10, ...["Source memo hit.", {"stone": this}]);
+				return cached;
+			};
+			let p = this.project.cache.getSource(this);
+			ctx.sources.set(this, p);
+			return p;
+		};
+		let _gthis = this;
+		return MemoContext.ensure(function () {
+			let newCtx = MemoContext.als.getStore();
+			let p = _gthis.project.cache.getSource(_gthis);
+			newCtx.sources.set(_gthis, p);
+			return p;
+		});
 	}
 	
 	/**
@@ -126,6 +145,44 @@ class Stone extends Register.inherits() {
 	*/
 	getHash() {
 		Log.log(20, ...["Generating hash.", {"stone": this}]);
+		let ctx = MemoContext.als.getStore();
+		if (ctx != null) {
+			let cached = ctx.hashes.get(this);
+			if (cached != null) {
+				Log.log(10, ...["Hash memo hit.", {"stone": this}]);
+				return cached;
+			};
+			let _gthis = this;
+			let p = this.finalMaybeHash().then(function (hash) {
+				if (hash != null) {
+					return hash;
+				} else {
+					return _gthis.getSource().then(function (s) {
+						return s.hash;
+					});
+				};
+			});
+			ctx.hashes.set(this, p);
+			return p;
+		};
+		let _gthis = this;
+		return MemoContext.ensure(function () {
+			let newCtx = MemoContext.als.getStore();
+			let _gthis1 = _gthis;
+			let p = _gthis.finalMaybeHash().then(function (hash) {
+				if (hash != null) {
+					return hash;
+				} else {
+					return _gthis1.getSource().then(function (s) {
+						return s.hash;
+					});
+				};
+			});
+			newCtx.hashes.set(_gthis, p);
+			return p;
+		});
+	}
+	_computeHash() {
 		let _gthis = this;
 		return this.finalMaybeHash().then(function (hash) {
 			if (hash != null) {
@@ -340,6 +397,74 @@ class Stone extends Register.inherits() {
 		return Promise.resolve(null);
 	}
 	
+	/**
+	* Optional override: compute expensive shared state once and reuse it across all
+	* `list()` / `generatePartial()` calls within a generation batch. Without this, work like
+	* enumerating inputs, resolving pipelines, or building lookup maps gets repeated once per output.
+	*
+	* Override to do the upfront work; call `getContext()` (not this) from `list()`/`generatePartial()`
+	* to read it. The result is cached (see `getContext` for the caching rules). The returned object
+	* is held by reference and never serialized — Maps, class instances, and closures are fine.
+	*
+	* **Constraint**: `generateContext` must not call back into this *same* stone's `getSource()` /
+	* `getPartialSource()` — it runs inside this stone's `acquire()` lock and would deadlock. Reading
+	* from *other* stones (dependencies) is fine.
+	*/
+	generateContext(hash) {
+		return Promise.resolve(null);
+	}
+	
+	/**
+	* **Do not override** (override `generateContext` instead). Returns the shared context,
+	* computing it via `generateContext` at most once per key. Callable from `list()`,
+	* `generatePartial()`, or `generateHash()`.
+	*
+	* Caching:
+	* - With a stable (non-null) hash, the resolved Promise is cached on the stone instance keyed by
+	*   that hash, so it is reused across separate `getSource()`/`getPartialSource()` calls — even
+	*   across builds — as long as the hash matches. A changed hash recomputes.
+	* - With a null hash (a stone without `generateHash()`), there is no stable key, so the context is
+	*   scoped to the current request via `MemoContext` instead of the instance. This still shares it
+	*   across the `Promise.all` batch in the default `generate()`, but avoids holding stale state
+	*   across builds.
+	*
+	* In both cases the *Promise* (not the resolved value) is cached, so concurrent callers from the
+	* same batch share one in-flight computation rather than racing to start their own.
+	*
+	* @param hash Pass the hash when you already have it (from `generatePartial`); omit it elsewhere
+	* (e.g. `list()`) and it is derived via `finalMaybeHash()` without forcing generation.
+	*/
+	getContext(hash) {
+		if (hash != null) {
+			return this._contextForHash(hash);
+		};
+		let _gthis = this;
+		return this.finalMaybeHash().then(function (h) {
+			return _gthis._contextForHash(h);
+		});
+	}
+	_contextForHash(hash) {
+		if (hash == null) {
+			let ctx = MemoContext.als.getStore();
+			if (ctx == null) {
+				return this.generateContext(null);
+			};
+			let cached = ctx.contexts.get(this);
+			if (cached != null) {
+				return cached;
+			};
+			let p = this.generateContext(null);
+			ctx.contexts.set(this, p);
+			return p;
+		};
+		if (this._contextPromise != null && this._contextPromise.hash != null && SourceHash.equals(this._contextPromise.hash, hash)) {
+			return this._contextPromise.promise;
+		};
+		let p = this.generateContext(hash);
+		this._contextPromise = {"hash": hash, "promise": p};
+		return p;
+	}
+	
 	/**
 	* Get source for a single output by sourceId.
 	* If the stone implements generatePartial(), generates just the requested output.
@@ -347,6 +472,41 @@ class Stone extends Register.inherits() {
 	* Uses the same cache as getSource() — partial and full share the pool.
 	*/
 	getPartialSource(sourceId) {
+		let ctx = MemoContext.als.getStore();
+		if (ctx != null) {
+			let partialMap = ctx.partials.get(this);
+			if (partialMap != null) {
+				let cached = partialMap.get(sourceId);
+				if (cached != null) {
+					Log.log(10, ...["Partial source memo hit.", {"stone": this, "sourceId": sourceId}]);
+					return cached;
+				};
+			};
+			let fullCached = ctx.sources.get(this);
+			if (fullCached != null) {
+				return fullCached.then(function (s) {
+					return s.filterTo(sourceId);
+				});
+			};
+			let p = this._computePartialSource(sourceId);
+			if (partialMap == null) {
+				partialMap = new Map();
+				ctx.partials.set(this, partialMap);
+			};
+			partialMap.set(sourceId, p);
+			return p;
+		};
+		let _gthis = this;
+		return MemoContext.ensure(function () {
+			let newCtx = MemoContext.als.getStore();
+			let p = _gthis._computePartialSource(sourceId);
+			let partialMap = new Map();
+			newCtx.partials.set(_gthis, partialMap);
+			partialMap.set(sourceId, p);
+			return p;
+		});
+	}
+	_computePartialSource(sourceId) {
 		let _gthis = this;
 		return this.finalMaybeHash().then(function (hash) {
 			if (hash == null) {
@@ -555,4 +715,5 @@ Stone.prototype.cacheStrategy = null;
 Stone.prototype.project = null;
 Stone.prototype.lockQueue = null;
 Stone.prototype.locked = null;
+Stone.prototype._contextPromise = null;
 

package/bin/whet/Whet.d.ts

@@ -1,4 +1,4 @@
-import {Command} from "commander"
+import {Command, Option} from "commander"
 
 export const program: Command
 export const main: () => void

package/bin/whet/Whet.js

@@ -26,7 +26,7 @@ class Whet_Fields_ {
 		if (entryUrl != thisUrl) {
 			return;
 		};
-		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.2.0", "-v, --version").allowUnknownOption(true).allowExcessArguments(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").option("--profile <format>", "enable profiling, export to whet-profile.json on exit (format: json or trace, default: json)").exitOverride();
+		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.5.0", "-v, --version").allowUnknownOption(true).allowExcessArguments(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").option("--profile <format>", "enable profiling, export to whet-profile.json on exit (format: json or trace, default: json)").exitOverride();
 		try {
 			Whet_Fields_.program.parse();
 		}catch (_g) {
@@ -87,6 +87,10 @@ class Whet_Fields_ {
 			while (_g2 < _g3.length) Whet_Fields_.program.addOption(_g3[_g2++]);
 		};
 		Whet_Fields_.program.allowUnknownOption(false);
+		let schemaCmd = new Command("schema");
+		schemaCmd.description("Export project schema as JSON.");
+		schemaCmd.action(Whet_Fields_.outputSchema);
+		Whet_Fields_.program.addCommand(schemaCmd);
 		let commands = Whet_Fields_.getCommands(Whet_Fields_.program.args);
 		let initProm;
 		if (commands.length > 0) {
@@ -150,6 +154,50 @@ class Whet_Fields_ {
 			nextCommand();
 		});
 	}
+	static outputSchema() {
+		Log.logLevel = 100;
+		let excludeCommands = ["help", "schema"];
+		let _g = [];
+		let _g1 = 0;
+		let _g2 = Project.projects;
+		while (_g1 < _g2.length) {
+			let p = _g2[_g1];
+			++_g1;
+			let p1 = p.name;
+			let p2 = p.id;
+			let p3 = p.description;
+			let _g3 = [];
+			let _g4 = 0;
+			let _g5 = p.options;
+			while (_g4 < _g5.length) _g3.push(Whet_Fields_.serializeOption(_g5[_g4++]));
+			_g.push({"name": p1, "id": p2, "description": p3, "options": _g3});
+		};
+		let _g3 = [];
+		let _g4 = 0;
+		let _g5 = Whet_Fields_.program.commands;
+		while (_g4 < _g5.length) {
+			let cmd = _g5[_g4];
+			++_g4;
+			let x = cmd.name();
+			if (!excludeCommands.includes(x)) {
+				_g3.push(Whet_Fields_.serializeCommand(cmd));
+			};
+		};
+		process.stdout.write(JSON.stringify({"projects": _g, "commands": _g3}, null, "  ") + "\n");
+	}
+	static serializeOption(opt) {
+		return {"name": opt.name(), "attributeName": opt.attributeName(), "flags": opt.flags, "description": opt.description, "choices": opt.argChoices, "defaultValue": opt.defaultValue, "required": opt.required, "mandatory": opt.mandatory, "boolean": opt.isBoolean(), "hidden": opt.hidden};
+	}
+	static serializeCommand(cmd) {
+		let tmp = cmd.name();
+		let tmp1 = cmd.description();
+		let tmp2 = cmd.aliases();
+		let _g = [];
+		let _g1 = 0;
+		let _g2 = cmd.options;
+		while (_g1 < _g2.length) _g.push(Whet_Fields_.serializeOption(_g2[_g1++]));
+		return {"name": tmp, "description": tmp1, "aliases": tmp2, "options": _g};
+	}
 	static getCommands(args) {
 		let commands = [];
 		let from = 0;

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

@@ -27,6 +27,11 @@ export declare class BaseCache<Key, Value extends {
 	protected shouldKeep(stone: AnyStone, val: Value, durability: CacheDurability, useIndex: ((arg0: Value) => number), ageIndex: ((arg0: Value) => number)): boolean
 	protected setRecentUseOrder(values: Value[], value: Value): boolean
 	protected remove(stone: AnyStone, value: Value): Promise<any>
+	
+	/**
+	Remove all cached entries for a stone.
+	*/
+	clearStone(stone: AnyStone): void
 	protected key(stone: AnyStone): Key
 	protected value(source: Source): Promise<Value>
 	protected source(stone: AnyStone, value: Value): Promise<Source>

package/bin/whet/cache/BaseCache.js

@@ -361,6 +361,13 @@ class BaseCache extends Register.inherits() {
 		HxOverrides.remove(this.cache.get(this.key(stone)), value);
 		return Promise.resolve(null);
 	}
+	
+	/**
+	Remove all cached entries for a stone.
+	*/
+	clearStone(stone) {
+		this.cache.remove(this.key(stone));
+	}
 	toString() {
 		let c = Boot.getClass(this);
 		return c.__name__;

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

@@ -31,5 +31,10 @@ export declare class CacheManager {
 	* The path is not reserved. Caching depends on stone's `cacheStrategy` and success of source generation.
 	*/
 	getDir(stone: AnyStone, hash?: null | SourceHash): string
+	
+	/**
+	Remove all cached entries for a stone. Opt-in – not called automatically by Project.removeStone.
+	*/
+	clearStone(stone: AnyStone): void
 	close(): Promise<void>
 }

package/bin/whet/cache/CacheManager.js

@@ -233,6 +233,14 @@ class CacheManager extends Register.inherits() {
 		};
 		return id;
 	}
+	
+	/**
+	Remove all cached entries for a stone. Opt-in – not called automatically by Project.removeStone.
+	*/
+	clearStone(stone) {
+		this.memCache.clearStone(stone);
+		this.fileCache.clearStone(stone);
+	}
 	close() {
 		return this.fileCache.close();
 	}

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

@@ -15,6 +15,7 @@ export declare class FileCache extends BaseCache<string, RuntimeFileCacheValue>
 	protected set(source: Source): Promise<RuntimeFileCacheValue>
 	protected getExistingDirs(stone: AnyStone): string[]
 	protected remove(stone: AnyStone, value: RuntimeFileCacheValue): Promise<any>
+	clearStone(stone: AnyStone): void
 	protected setRecentUseOrder(values: RuntimeFileCacheValue[], value: RuntimeFileCacheValue): boolean
 	protected getDirFor(value: RuntimeFileCacheValue): string
 	protected hasSourceId(value: RuntimeFileCacheValue, sourceId: string): boolean

package/bin/whet/cache/FileCache.js

@@ -220,6 +220,10 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 			});
 		});
 	}
+	clearStone(stone) {
+		super.clearStone(stone);
+		this.flush();
+	}
 	setRecentUseOrder(values, value) {
 		let changed = super.setRecentUseOrder(values, value);
 		if (changed) {

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

@@ -0,0 +1,18 @@
+import {AnyStone} from "../Stone"
+import {SourceHash} from "../SourceHash"
+import {Source} from "../Source"
+import {AsyncLocalStorage} from "node:async_hooks"
+
+export declare class MemoContext {
+	constructor()
+	protected sources: Map<AnyStone, Promise<Source>>
+	protected hashes: Map<AnyStone, Promise<SourceHash>>
+	protected partials: Map<AnyStone, Map<string, Promise<null | Source>>>
+	protected contexts: Map<AnyStone, Promise<any>>
+	protected static als: AsyncLocalStorage<MemoContext>
+	
+	/**
+	Execute fn within a MemoContext. Reuses existing context or creates a new one.
+	*/
+	static ensure<T>(fn: (() => T)): T
+}

package/bin/whet/cache/MemoContext.js

@@ -0,0 +1,37 @@
+import {AsyncLocalStorage} from "node:async_hooks"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const MemoContext = Register.global("$hxClasses")["whet.cache.MemoContext"] = 
+class MemoContext extends Register.inherits() {
+	[Register.new]() {
+		this.contexts = new Map();
+		this.partials = new Map();
+		this.hashes = new Map();
+		this.sources = new Map();
+	}
+	
+	/**
+	Execute fn within a MemoContext. Reuses existing context or creates a new one.
+	*/
+	static ensure(fn) {
+		if (MemoContext.als.getStore() != null) {
+			return fn();
+		};
+		return MemoContext.als.run(new MemoContext(), fn);
+	}
+	static get __name__() {
+		return "whet.cache.MemoContext"
+	}
+	get __class__() {
+		return MemoContext
+	}
+}
+MemoContext.prototype.sources = null;
+MemoContext.prototype.hashes = null;
+MemoContext.prototype.partials = null;
+MemoContext.prototype.contexts = null;
+
+
+MemoContext.als = new AsyncLocalStorage()

package/bin/whet/magic/RoutePathType.js

@@ -11,7 +11,7 @@ export const RoutePathType_Fields_ = Register.global("$hxClasses")["whet.magic._
 class RoutePathType_Fields_ {
 	static makeRoutePath(routerPathType) {
 		if (((routerPathType) instanceof Router) || ((routerPathType) instanceof Stone) || typeof(routerPathType) == "string") {
-			return [{"routeUnder": "", "source": (typeof(routerPathType) == "string") ? new Files({"paths": [routerPathType]}) : routerPathType, "filter": null, "extractDirs": null}];
+			return [{"routeUnder": "", "source": (typeof(routerPathType) == "string") ? Files.fromPath(routerPathType) : routerPathType, "filter": null, "extractDirs": null}];
 		};
 		if (!((routerPathType) instanceof Array)) {
 			throw new Error("RoutePath should be a Stone, Router, or an array.");
@@ -23,7 +23,7 @@ class RoutePathType_Fields_ {
 			let item = _g2[_g1];
 			++_g1;
 			if (((item) instanceof Router) || ((item) instanceof Stone) || typeof(item) == "string") {
-				_g.push({"routeUnder": "", "source": (typeof(item) == "string") ? new Files({"paths": [item]}) : item, "filter": null, "extractDirs": null});
+				_g.push({"routeUnder": "", "source": (typeof(item) == "string") ? Files.fromPath(item) : item, "filter": null, "extractDirs": null});
 			} else if (((item) instanceof Array)) {
 				let inner = item;
 				if (typeof(inner[0]) != "string") {
@@ -36,12 +36,12 @@ class RoutePathType_Fields_ {
 				switch (inner.length) {
 					case 2:
 						let src = inner[1];
-						let tmp1 = (typeof(src) == "string") ? new Files({"paths": [src]}) : src;
+						let tmp1 = (typeof(src) == "string") ? Files.fromPath(src) : src;
 						tmp = {"routeUnder": inner[0], "source": tmp1, "filter": null, "extractDirs": null};
 						break
 					case 3:
 						let src1 = inner[1];
-						let tmp2 = (typeof(src1) == "string") ? new Files({"paths": [src1]}) : src1;
+						let tmp2 = (typeof(src1) == "string") ? Files.fromPath(src1) : src1;
 						if (!(typeof(inner[2]) == "string" || inner[2] instanceof Minimatch)) {
 							throw new Error("Third" + " element of RoutePath array should be a glob pattern (string or `minimatch` object)");
 						};
@@ -50,7 +50,7 @@ class RoutePathType_Fields_ {
 						break
 					case 4:
 						let src2 = inner[1];
-						let tmp4 = (typeof(src2) == "string") ? new Files({"paths": [src2]}) : src2;
+						let tmp4 = (typeof(src2) == "string") ? Files.fromPath(src2) : src2;
 						if (!(typeof(inner[2]) == "string" || inner[2] instanceof Minimatch)) {
 							throw new Error("Third" + " element of RoutePath array should be a glob pattern (string or `minimatch` object)");
 						};

package/bin/whet/profiler/Profiler.d.ts

@@ -1,6 +1,6 @@
 import {SpanStats} from "./SpanStats"
 import {SpanRecorder} from "./SpanRecorder"
-import {SpanEvent, AnySpan, SpanEventType} from "./Span"
+import {SpanEvent, AnySpan, SpanStatus, SpanEventType} from "./Span"
 import {AnyStone} from "../Stone"
 import {AsyncLocalStorage} from "node:async_hooks"
 
@@ -19,6 +19,11 @@ export declare class Profiler {
 	*/
 	withSpan<T, R>(stone: AnyStone, op: string, fn: (() => Promise<R>), meta?: null | T): Promise<R>
 	
+	/**
+	Finalize a span's timing/status, record it, and emit the End event.
+	*/
+	protected finishSpan(span: AnySpan, status: SpanStatus): void
+	
 	/**
 	Secondary API: manual start for spans where no function can be wrapped (e.g. LockWait).
 	*/

package/bin/whet/profiler/Profiler.js

@@ -3,6 +3,7 @@ import {SpanRecorder} from "./SpanRecorder.js"
 import {Span, SpanEventType, SpanStatus} from "./Span.js"
 import {AsyncLocalStorage} from "node:async_hooks"
 import {IntMap} from "../../haxe/ds/IntMap.js"
+import {Exception} from "../../haxe/Exception.js"
 import {EsMap} from "../../genes/util/EsMap.js"
 import {Register} from "../../genes/Register.js"
 import {Std} from "../../Std.js"
@@ -33,25 +34,36 @@ class Profiler extends Register.inherits() {
 		this.emit(SpanEventType.Start, span);
 		let _gthis = this;
 		return this.context.run(span, function () {
-			return fn().then(function (result) {
-				span.endTime = performance.now();
-				span.duration = span.endTime - span.startTime;
-				span.status = SpanStatus.Ok;
-				_gthis.recorder.record(span);
-				_gthis.stats.update(stone.id, op, span.duration);
-				_gthis.emit(SpanEventType.End, span);
-				return result;
-			})["catch"](function (err) {
-				span.endTime = performance.now();
-				span.duration = span.endTime - span.startTime;
-				span.status = SpanStatus.Error(Std.string(err));
-				_gthis.recorder.record(span);
-				_gthis.emit(SpanEventType.End, span);
-				return Promise.reject(err);
-			});
+			try {
+				return fn().then(function (result) {
+					_gthis.finishSpan(span, SpanStatus.Ok);
+					return result;
+				})["catch"](function (err) {
+					_gthis.finishSpan(span, SpanStatus.Error(Std.string(err)));
+					return Promise.reject(err);
+				});
+			}catch (_g) {
+				let _g1 = Exception.caught(_g).unwrap();
+				_gthis.finishSpan(span, SpanStatus.Error(Std.string(_g1)));
+				return Promise.reject(_g1);
+			};
 		});
 	}
 	
+	/**
+	Finalize a span's timing/status, record it, and emit the End event.
+	*/
+	finishSpan(span, status) {
+		span.endTime = performance.now();
+		span.duration = span.endTime - span.startTime;
+		span.status = status;
+		this.recorder.record(span);
+		if (status == SpanStatus.Ok) {
+			this.stats.update(span.stone, span.operation, span.duration);
+		};
+		this.emit(SpanEventType.End, span);
+	}
+	
 	/**
 	Secondary API: manual start for spans where no function can be wrapped (e.g. LockWait).
 	*/

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

@@ -11,6 +11,11 @@ export declare class Router {
 	protected routes: RoutePath[]
 	route(r: RoutePathType): void
 	
+	/**
+	Remove all routes.
+	*/
+	clearRoutes(): void
+	
 	/**
 	Recursively collect all Stone IDs referenced in this Router's routes.
 	*/
@@ -29,6 +34,19 @@ export declare class Router {
 	*/
 	getHash(pattern?: null | MinimatchType): Promise<SourceHash>
 	
+	/**
+	* Hash for the no-query-filter case: a per-route token binding the source's hash to the
+	* static route structure (mount path, filter, extractDirs), then merged order-independently.
+	* Child routers recurse through getHash() with no pattern, so nested structure folds in at each
+	* level. No id enumeration, so stones without list() are not forced to generate.
+	*
+	* Binding structure to source per route is what keeps this false-hit-safe: the set of served
+	* ids is a function of each route's (mount/filter/extractDirs) plus its source id-set, and the
+	* source's hash moves with its id-set. Sorting the per-route tokens makes route order
+	* irrelevant (matching the long-standing contract) without losing that binding.
+	*/
+	protected getUnfilteredHash(): Promise<SourceHash>
+	
 	/**
 	* Save files filtered by `pattern` into provided `saveInto` folder.
 	*/

package/bin/whet/route/Router.js

@@ -2,6 +2,7 @@ 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 {MemoContext} from "../cache/MemoContext.js"
 import {Utils} from "../Utils.js"
 import {Stone} from "../Stone.js"
 import {SourceHash} from "../SourceHash.js"
@@ -21,6 +22,13 @@ class Router extends Register.inherits() {
 		while (_g < _g1.length) this.routes.push(_g1[_g++]);
 	}
 	
+	/**
+	Remove all routes.
+	*/
+	clearRoutes() {
+		this.routes.length = 0;
+	}
+	
 	/**
 	Recursively collect all Stone IDs referenced in this Router's routes.
 	*/
@@ -56,7 +64,10 @@ class Router extends Register.inherits() {
 	* @param pattern A glob pattern to search for.
 	*/
 	get(pattern) {
-		return this.getResults([{"pathSoFar": [], "filter": (pattern != null) ? MinimatchType_Fields_.makeMinimatch(pattern) : null, "inProgress": true, "remDirs": []}], []);
+		let _gthis = this;
+		return MemoContext.ensure(function () {
+			return _gthis.getResults([{"pathSoFar": [], "filter": (pattern != null) ? MinimatchType_Fields_.makeMinimatch(pattern) : null, "inProgress": true, "remDirs": []}], []);
+		});
 	}
 	getResults(mainFilters, results) {
 		let _gthis = this;
@@ -207,46 +218,99 @@ class Router extends Register.inherits() {
 	* 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];
-				++_g;
-				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 _gthis = this;
+		if (pattern == null) {
+			return MemoContext.ensure(function () {
+				return _gthis.getUnfilteredHash();
 			});
-			let result = new Array(uniqueStones.length);
-			let _g1 = 0;
-			let _g2 = uniqueStones.length;
-			while (_g1 < _g2) {
-				let i = _g1++;
-				result[i] = uniqueStones[i].getHash();
-			};
-			return Promise.all(result).then(function (hashes) {
-				hashes.sort(function (a, b) {
-					if (a.toString() < b.toString()) {
+		};
+		return MemoContext.ensure(function () {
+			return _gthis.get(pattern).then(function (items) {
+				let uniqueStones = [];
+				let serveIds = [];
+				let _g = 0;
+				while (_g < items.length) {
+					let item = items[_g];
+					++_g;
+					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.toString() > b.toString()) {
+					} else if (a > b) {
 						return 1;
 					} else {
 						return 0;
 					};
 				});
-				return SourceHash.merge(...hashes).add(SourceHash.fromString(serveIds.join("\n")));
+				let result = new Array(uniqueStones.length);
+				let _g1 = 0;
+				let _g2 = uniqueStones.length;
+				while (_g1 < _g2) {
+					let i = _g1++;
+					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")));
+				});
+			});
+		});
+	}
+	
+	/**
+	* Hash for the no-query-filter case: a per-route token binding the source's hash to the
+	* static route structure (mount path, filter, extractDirs), then merged order-independently.
+	* Child routers recurse through getHash() with no pattern, so nested structure folds in at each
+	* level. No id enumeration, so stones without list() are not forced to generate.
+	*
+	* Binding structure to source per route is what keeps this false-hit-safe: the set of served
+	* ids is a function of each route's (mount/filter/extractDirs) plus its source id-set, and the
+	* source's hash moves with its id-set. Sorting the per-route tokens makes route order
+	* irrelevant (matching the long-standing contract) without losing that binding.
+	*/
+	getUnfilteredHash() {
+		let tokenProms = [];
+		let _g = 0;
+		let _g1 = this.routes;
+		while (_g < _g1.length) {
+			let route = _g1[_g];
+			++_g;
+			let structure = route.routeUnder + "|" + ((route.filter != null) ? route.filter.pattern : "") + "|" + ((route.extractDirs != null) ? route.extractDirs.pattern : "");
+			let childHash;
+			if (((route.source) instanceof Stone)) {
+				childHash = route.source.getHash();
+			} else if (((route.source) instanceof Router)) {
+				childHash = route.source.getHash();
+			} else {
+				throw new Error("Router source must be a Stone or a Router.");
+			};
+			tokenProms.push(childHash.then(function (h) {
+				return SourceHash.fromString(structure).add(h);
+			}));
+		};
+		return Promise.all(tokenProms).then(function (tokens) {
+			tokens.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(...tokens);
 		});
 	}
 	

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

@@ -18,6 +18,11 @@ export declare class Files extends Stone<FilesConfig> {
 		id: string, 
 		pathId: string
 	}
+	
+	/**
+	Reuse an existing Files stone for this path, or create a new one.
+	*/
+	static fromPath(path: string): Files
 }
 
 export type FilesConfig = {

package/bin/whet/stones/Files.js

@@ -5,6 +5,7 @@ import {Stone} from "../Stone.js"
 import {IdUtils, RootDir} from "../SourceId.js"
 import {SourceHash} from "../SourceHash.js"
 import {SourceData} from "../Source.js"
+import {Project} from "../Project.js"
 import {Register} from "../../genes/Register.js"
 
 const $global = Register.$global
@@ -164,6 +165,25 @@ class Files extends Register.inherits(() => Stone, true) {
 		};
 		return {"pathId": pathId, "id": tmp};
 	}
+	
+	/**
+	Reuse an existing Files stone for this path, or create a new one.
+	*/
+	static fromPath(path) {
+		let project = Project.projects[Project.projects.length - 1];
+		if (project != null) {
+			let _g = 0;
+			let _g1 = project.stones;
+			while (_g < _g1.length) {
+				let stone = _g1[_g];
+				++_g;
+				if (stone.id == path && ((stone) instanceof Files)) {
+					return stone;
+				};
+			};
+		};
+		return new Files({"paths": [path]});
+	}
 	static get __name__() {
 		return "whet.stones.Files"
 	}

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

@@ -0,0 +1,55 @@
+import {Router} from "../route/Router"
+import {RoutePathType} from "../magic/RoutePathType"
+import {AnyStone} from "../Stone"
+
+/**
+* Base class for dynamic stone lifecycle management.
+*
+* Manages creation, update, and removal of stones based on external data.
+* Extends Router so it can be used directly as a route source.
+*
+* JS subclasses override `createEntry`, `updateEntry`, and `addBaseRoutes`.
+*/
+export declare class StoneFactory<D, E extends FactoryEntry> extends Router {
+	constructor(routes?: null | RoutePathType)
+	entryMap: Map<string, E>
+	
+	/**
+	* Sync factory state with data. Calls `createEntry` for new keys,
+	* `updateEntry` for existing keys, and removes entries whose keys are absent.
+	* @return Array of removed keys (caller can use for cache cleanup via `cache.clearStone`).
+	*/
+	sync(data: D[], keyFn: ((arg0: D) => string)): string[]
+	
+	/**
+	Override in subclass: create stones and routes for a new data entry.
+	*/
+	protected createEntry(key: string, data: D): E
+	
+	/**
+	* Override in subclass: update an existing entry's stone configs in-place.
+	* Default implementation destroys and recreates the entry.
+	*/
+	protected updateEntry(key: string, data: D, existing: E): void
+	
+	/**
+	Override in subclass: add routes that are present on every sync (e.g., a database JSON file).
+	*/
+	protected addBaseRoutes(): void
+	
+	/**
+	Remove an entry, deregistering its stones from the project.
+	*/
+	removeEntry(key: string): void
+}
+
+export type FactoryEntry = {
+	/**
+	Route definitions for this entry — added to the factory's Router on sync.
+	*/
+	routes?: null | RoutePathType, 
+	/**
+	Stones owned by this entry — deregistered from project on removal.
+	*/
+	stones: AnyStone[]
+}

package/bin/whet/stones/StoneFactory.js

@@ -0,0 +1,116 @@
+import {Router} from "../route/Router.js"
+import {RoutePathType_Fields_} from "../magic/RoutePathType.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+* Base class for dynamic stone lifecycle management.
+*
+* Manages creation, update, and removal of stones based on external data.
+* Extends Router so it can be used directly as a route source.
+*
+* JS subclasses override `createEntry`, `updateEntry`, and `addBaseRoutes`.
+*/
+export const StoneFactory = Register.global("$hxClasses")["whet.stones.StoneFactory"] = 
+class StoneFactory extends Register.inherits(Router) {
+	[Register.new](routes) {
+		this.entryMap = new Map();
+		super[Register.new](routes);
+	}
+	
+	/**
+	* Sync factory state with data. Calls `createEntry` for new keys,
+	* `updateEntry` for existing keys, and removes entries whose keys are absent.
+	* @return Array of removed keys (caller can use for cache cleanup via `cache.clearStone`).
+	*/
+	sync(data, keyFn) {
+		let newKeys = new Set();
+		this.clearRoutes();
+		this.addBaseRoutes();
+		let _g = 0;
+		while (_g < data.length) {
+			let item = data[_g];
+			++_g;
+			let key = keyFn(item);
+			newKeys.add(key);
+			if (this.entryMap.has(key)) {
+				this.updateEntry(key, item, this.entryMap.get(key));
+			} else {
+				this.entryMap.set(key, this.createEntry(key, item));
+			};
+			let entry = this.entryMap.get(key);
+			if (entry.routes != null) {
+				let _g = 0;
+				let _g1 = RoutePathType_Fields_.makeRoutePath(entry.routes);
+				while (_g < _g1.length) this.routes.push(_g1[_g++]);
+			};
+		};
+		let toRemove = [];
+		let jsIterator = this.entryMap.keys();
+		let _g_lastStep = jsIterator.next();
+		while (!_g_lastStep.done) {
+			let v = _g_lastStep.value;
+			_g_lastStep = jsIterator.next();
+			if (!newKeys.has(v)) {
+				toRemove.push(v);
+			};
+		};
+		let _g1 = 0;
+		while (_g1 < toRemove.length) this.removeEntry(toRemove[_g1++]);
+		return toRemove;
+	}
+	
+	/**
+	Override in subclass: create stones and routes for a new data entry.
+	*/
+	createEntry(key, data) {
+		throw new Error("StoneFactory.createEntry must be overridden");
+	}
+	
+	/**
+	* Override in subclass: update an existing entry's stone configs in-place.
+	* Default implementation destroys and recreates the entry.
+	*/
+	updateEntry(key, data, existing) {
+		this.removeEntry(key);
+		this.entryMap.set(key, this.createEntry(key, data));
+	}
+	
+	/**
+	Override in subclass: add routes that are present on every sync (e.g., a database JSON file).
+	*/
+	addBaseRoutes() {
+	}
+	
+	/**
+	Remove an entry, deregistering its stones from the project.
+	*/
+	removeEntry(key) {
+		let entry = this.entryMap.get(key);
+		if (entry == null) {
+			return;
+		};
+		if (entry.stones != null) {
+			let stones = entry.stones;
+			let _g = 0;
+			while (_g < stones.length) {
+				let s = stones[_g];
+				++_g;
+				s.project.removeStone(s);
+			};
+		};
+		this.entryMap["delete"](key);
+	}
+	static get __name__() {
+		return "whet.stones.StoneFactory"
+	}
+	static get __super__() {
+		return Router
+	}
+	get __class__() {
+		return StoneFactory
+	}
+}
+StoneFactory.prototype.entryMap = null;
+

package/bin/whet.d.ts

@@ -3,6 +3,7 @@ export {addOption} from "./whet/Project"
 export {ZipStone} from "./whet/stones/Zip"
 export {ZipConfig} from "./whet/stones/Zip"
 export {Utils} from "./whet/Utils"
+export {StoneFactory} from "./whet/stones/StoneFactory"
 export {Stone} from "./whet/Stone"
 export {Router} from "./whet/route/Router"
 export {RemoteFileConfig} from "./whet/stones/RemoteFile"
@@ -17,6 +18,7 @@ export {Hxml} from "./whet/stones/haxe/Hxml"
 export {HaxeBuild} from "./whet/stones/haxe/HaxeBuild"
 export {FilesConfig} from "./whet/stones/Files"
 export {Files} from "./whet/stones/Files"
+export {FactoryEntry} from "./whet/stones/StoneFactory"
 export {DCE} from "./whet/stones/haxe/Hxml"
 export {ConfigStore} from "./whet/ConfigStore"
 export {BuildPlatform} from "./whet/stones/haxe/Hxml"

package/bin/whet.js

@@ -8,6 +8,7 @@ Whet_Fields_.main()
 export {addOption} from "./whet/Project.js"
 export {ZipStone} from "./whet/stones/Zip.js"
 export {Utils} from "./whet/Utils.js"
+export {StoneFactory} from "./whet/stones/StoneFactory.js"
 export {Stone} from "./whet/Stone.js"
 export {Router} from "./whet/route/Router.js"
 export {RemoteFile} from "./whet/stones/RemoteFile.js"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "whet",
-    "version": "0.2.0",
+    "version": "0.5.0",
     "description": "NodeJS based assets management and project tooling library.",
     "scripts": {
         "devinit": "npx dts2hx commander pino-pretty minimatch --modular --noLibWrap",
@@ -27,7 +27,7 @@
     "homepage": "https://github.com/Antriel/whet#readme",
     "dependencies": {
         "commander": "^14.0.3",
-        "minimatch": "^10.2.4",
+        "minimatch": "^10.2.5",
         "pino-pretty": "^13.1.3"
     },
     "devDependencies": {