whet 0.4.0 → 0.5.0

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/Stone.d.ts

@@ -121,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.

package/bin/whet/Stone.js

@@ -16,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;
@@ -396,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.
@@ -646,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.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.4.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) {

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

@@ -8,6 +8,7 @@ export declare class MemoContext {
 	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>
 	
 	/**

package/bin/whet/cache/MemoContext.js

@@ -6,6 +6,7 @@ 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();
@@ -30,6 +31,7 @@ class MemoContext extends Register.inherits() {
 MemoContext.prototype.sources = null;
 MemoContext.prototype.hashes = null;
 MemoContext.prototype.partials = null;
+MemoContext.prototype.contexts = null;
 
 
 MemoContext.als = new AsyncLocalStorage()

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

@@ -34,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

@@ -219,6 +219,11 @@ class Router extends Register.inherits() {
 	*/
 	getHash(pattern) {
 		let _gthis = this;
+		if (pattern == null) {
+			return MemoContext.ensure(function () {
+				return _gthis.getUnfilteredHash();
+			});
+		};
 		return MemoContext.ensure(function () {
 			return _gthis.get(pattern).then(function (items) {
 				let uniqueStones = [];
@@ -264,6 +269,51 @@ class Router extends Register.inherits() {
 		});
 	}
 	
+	/**
+	* 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);
+		});
+	}
+	
 	/**
 	* Save files filtered by `pattern` into provided `saveInto` folder.
 	*/

package/package.json

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