whet 0.1.1 → 0.4.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/ds/IntMap.d.ts

@@ -0,0 +1,6 @@
+import {IMap} from "../Constraints"
+import {EsMap} from "../../genes/util/EsMap"
+
+export declare class IntMap<T> extends EsMap<number, T> implements IMap<number, T> {
+	constructor()
+}

package/bin/haxe/ds/IntMap.js

@@ -0,0 +1,25 @@
+import {IMap} from "../Constraints.js"
+import {EsMap} from "../../genes/util/EsMap.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const IntMap = Register.global("$hxClasses")["haxe.ds.IntMap"] = 
+class IntMap extends Register.inherits(EsMap) {
+	[Register.new]() {
+		super[Register.new]();
+	}
+	static get __name__() {
+		return "haxe.ds.IntMap"
+	}
+	static get __interfaces__() {
+		return [IMap]
+	}
+	static get __super__() {
+		return EsMap
+	}
+	get __class__() {
+		return IntMap
+	}
+}
+

package/bin/haxe/ds/Vector.d.ts

@@ -0,0 +1,2 @@
+
+export type VectorData<T> = T[]

package/bin/minimatch/MinimatchOptions.d.ts

@@ -32,6 +32,34 @@ export type MinimatchOptions = {
 	*/
 	matchBase?: null | boolean, 
 	/**
+	Max depth to traverse for nested extglobs like `*(a|b|c)`
+	
+	Default is 2, which is quite low, but any higher value
+	swiftly results in punishing performance impacts. Note
+	that this is *not*  relevant when the globstar types can
+	be safely coalesced into a single set.
+	
+	For example, `*(a|@(b|c)|d)` would be flattened into
+	`*(a|b|c|d)`. Thus, many common extglobs will retain good
+	performance and  never hit this limit, even if they are
+	excessively deep and complicated.
+	
+	If the limit is hit, then the extglob characters are simply
+	not parsed, and the pattern effectively switches into
+	`noextglob: true` mode for the contents of that nested
+	sub-pattern. This will typically _not_ result in a match,
+	but is considered a valid trade-off for security and
+	performance.
+	*/
+	maxExtglobRecursion?: null | number, 
+	/**
+	Max number of non-adjacent `**` patterns to recursively walk down.
+	
+	The default of 200 is almost certainly high enough for most purposes,
+	and can handle absurdly excessive patterns.
+	*/
+	maxGlobstarRecursion?: null | number, 
+	/**
 	do not expand `{x,y}` style braces
 	*/
 	nobrace?: null | boolean, 

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

@@ -1,3 +1,4 @@
+import {Profiler, ProfilerConfig} from "./profiler/Profiler"
 import {CacheManager} from "./cache/CacheManager"
 import {CacheStrategy} from "./cache/Cache"
 import {AnyStone, OutputFilter} from "./Stone"
@@ -13,6 +14,7 @@ export declare class Project {
 	rootDir: string
 	cache: CacheManager
 	configStore: ConfigStore
+	profiler: null | Profiler
 	stones: AnyStone[]
 	onInit: (config: any) => Promise<any>
 	
@@ -22,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>
@@ -29,6 +36,8 @@ export declare class Project {
 	getStoneConfig(id: string): Promise<null | StoneConfigView>
 	setStoneConfig(id: string, patch: any, mode: string): Promise<boolean>
 	clearStoneConfigPreview(id: string): Promise<boolean>
+	enableProfiling(config?: null | ProfilerConfig): void
+	disableProfiling(): void
 	addCommand(name: string, stone?: null | AnyStone): Command
 	protected isCommandNameTaken(name: string): boolean
 	toString(): string
@@ -49,6 +58,10 @@ export type ProjectConfig = {
 	*/
 	onInit?: null | ((config: any) => Promise<any>), 
 	options?: null | Option[], 
+	/**
+	Enable profiling with optional config.
+	*/
+	profiler?: null | ProfilerConfig, 
 	rootDir?: null | string
 }
 

package/bin/whet/Project.js

@@ -1,4 +1,5 @@
 import {Router} from "./route/Router.js"
+import {Profiler} from "./profiler/Profiler.js"
 import {StoneId_Fields_} from "./magic/StoneId.js"
 import {MaybeArray_Fields_} from "./magic/MaybeArray.js"
 import {CacheManager} from "./cache/CacheManager.js"
@@ -18,6 +19,7 @@ export const Project = Register.global("$hxClasses")["whet.Project"] =
 class Project extends Register.inherits() {
 	[Register.new](config) {
 		this.stones = [];
+		this.profiler = null;
 		this.configStore = null;
 		this.cache = null;
 		Log.log(20, ...["Instantiating new Project."]);
@@ -55,6 +57,9 @@ class Project extends Register.inherits() {
 		};
 		this.configStore = config.configStore;
 		this.cache = (config.cache == null) ? new CacheManager(this) : config.cache;
+		if (config.profiler != null) {
+			this.profiler = new Profiler(config.profiler);
+		};
 		Project.projects.push(this);
 		Log.log(30, ...["New project created.", {"project": this, "projectCount": Project.projects.length}]);
 	}
@@ -70,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;
@@ -201,6 +218,14 @@ class Project extends Register.inherits() {
 		store.clearEntry(stone.id);
 		return Promise.resolve(true);
 	}
+	enableProfiling(config) {
+		if (this.profiler == null) {
+			this.profiler = new Profiler(config);
+		};
+	}
+	disableProfiling() {
+		this.profiler = null;
+	}
 	addCommand(name, stone) {
 		let cmdName = name;
 		let cmdAlias = null;
@@ -252,6 +277,7 @@ Project.prototype.description = null;
 Project.prototype.rootDir = null;
 Project.prototype.cache = null;
 Project.prototype.configStore = null;
+Project.prototype.profiler = null;
 Project.prototype.stones = null;
 Project.prototype.onInit = null;
 Project.prototype.config = null;

package/bin/whet/Stone.d.ts

@@ -1,3 +1,4 @@
+import {AnySpan} from "./profiler/Span"
 import {StoneIdType} from "./magic/StoneId"
 import {MaybeArray} from "./magic/MaybeArray"
 import {CacheManager} from "./cache/CacheManager"
@@ -54,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.**
@@ -126,6 +128,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,
@@ -184,6 +187,26 @@ export declare class Stone<T extends StoneConfig> {
 	* Useful for pure JS stones.
 	*/
 	cwdPath(path: string): string
+	
+	/**
+	Wraps an async operation in a profiler span. No-op when profiler is null.
+	*/
+	protected profilerWithSpan<T, R>(op: string, fn: (() => Promise<R>), meta?: null | T): Promise<R>
+	
+	/**
+	Starts a manual profiler span. Returns null when profiler is null.
+	*/
+	protected profilerStartSpan<T>(op: string, meta?: null | T): null | AnySpan
+	
+	/**
+	Ends a manual profiler span. No-op when span is null.
+	*/
+	protected profilerEndSpan(span: null | AnySpan): void
+	
+	/**
+	Returns the current span from ALS context, or null when profiler is disabled.
+	*/
+	protected profilerGetCurrentSpan(): null | AnySpan
 	protected get_cache(): CacheManager
 	toString(): string
 }

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"
@@ -75,13 +76,23 @@ class Stone extends Register.inherits() {
 		let _gthis = this;
 		if (this.locked) {
 			Log.log(20, ...["Stone is locked, waiting.", {"stone": this}]);
+			let waitSpan = (this.project.profiler != null) ? this.project.profiler.startSpan(this, "LockWait", {"queuePosition": this.lockQueue.length, "queueLength": this.lockQueue.length + 1}) : null;
 			let deferredRes;
 			let deferredRej;
 			let deferred = new Promise(function (res, rej) {
 				deferredRes = res;
 				deferredRej = rej;
 			});
-			this.lockQueue.push({"run": run, "res": deferredRes, "rej": deferredRej});
+			this.lockQueue.push({"run": function () {
+				if (waitSpan != null) {
+					_gthis.project.profiler.endSpan(waitSpan);
+				};
+				if (_gthis.project.profiler != null) {
+					return _gthis.project.profiler.withSpan(_gthis, "LockHeld", run, null);
+				} else {
+					return run();
+				};
+			}, "res": deferredRes, "rej": deferredRej});
 			return deferred;
 		} else {
 			this.locked = true;
@@ -96,7 +107,7 @@ class Stone extends Register.inherits() {
 					Log.log(10, ...["No function in lock queue. Stone is now unlocked.", {"stone": _gthis}]);
 				};
 			};
-			return run()["finally"](runNext);
+			return ((this.project.profiler != null) ? this.project.profiler.withSpan(this, "LockHeld", run, null) : run())["finally"](runNext);
 		};
 	}
 	
@@ -106,7 +117,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;
+		});
 	}
 	
 	/**
@@ -116,6 +144,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) {
@@ -158,13 +224,25 @@ class Stone extends Register.inherits() {
 			throw new Error("Acquire a lock before generating.");
 		};
 		Log.log(20, ...["Generating source.", {"stone": this, "hash": hash}]);
+		let deps = (this.config.dependencies != null) ? MaybeArray_Fields_.makeArray(this.config.dependencies) : null;
 		let init;
-		if (this.config.dependencies != null) {
+		if (deps != null) {
 			let _g = [];
 			let _g1 = 0;
-			let _g2 = MaybeArray_Fields_.makeArray(this.config.dependencies);
-			while (_g1 < _g2.length) _g.push(_g2[_g1++].getSource());
-			init = Promise.all(_g);
+			while (_g1 < deps.length) _g.push(deps[_g1++].id);
+			if (this.project.profiler != null) {
+				init = this.project.profiler.withSpan(this, "DependencyResolve", function () {
+					let _g = [];
+					let _g1 = 0;
+					while (_g1 < deps.length) _g.push(deps[_g1++].getSource());
+					return Promise.all(_g);
+				}, {"dependencyIds": _g});
+			} else {
+				let _g = [];
+				let _g1 = 0;
+				while (_g1 < deps.length) _g.push(deps[_g1++].getSource());
+				init = Promise.all(_g);
+			};
 		} else {
 			init = Promise.resolve(null);
 		};
@@ -325,6 +403,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) {
@@ -471,6 +584,48 @@ class Stone extends Register.inherits() {
 	cwdPath(path) {
 		return Path.posix.join(".", RootDir.fromProject(this.project), ".", path);
 	}
+	
+	/**
+	Wraps an async operation in a profiler span. No-op when profiler is null.
+	*/
+	profilerWithSpan(op, fn, meta) {
+		if (this.project.profiler != null) {
+			return this.project.profiler.withSpan(this, op, fn, meta);
+		} else {
+			return fn();
+		};
+	}
+	
+	/**
+	Starts a manual profiler span. Returns null when profiler is null.
+	*/
+	profilerStartSpan(op, meta) {
+		if (this.project.profiler != null) {
+			return this.project.profiler.startSpan(this, op, meta);
+		} else {
+			return null;
+		};
+	}
+	
+	/**
+	Ends a manual profiler span. No-op when span is null.
+	*/
+	profilerEndSpan(span) {
+		if (span != null) {
+			this.project.profiler.endSpan(span);
+		};
+	}
+	
+	/**
+	Returns the current span from ALS context, or null when profiler is disabled.
+	*/
+	profilerGetCurrentSpan() {
+		if (this.project.profiler != null) {
+			return this.project.profiler.getCurrentSpan();
+		} else {
+			return null;
+		};
+	}
 	get_cache() {
 		return this.project.cache;
 	}

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.1.1", "-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").exitOverride();
+		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();
 		try {
 			Whet_Fields_.program.parse();
 		}catch (_g) {
@@ -87,11 +87,34 @@ 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) {
 			let res = Whet_Fields_.program.parseOptions(commands[0]);
 			commands[0] = res.operands.concat(res.unknown);
+			let profileFormat = Whet_Fields_.program.opts().profile;
+			if (profileFormat != null) {
+				let format = (profileFormat == true) ? "json" : profileFormat;
+				let _g = 0;
+				let _g1 = Project.projects;
+				while (_g < _g1.length) _g1[_g++].enableProfiling();
+				let onExit = function () {
+					let _g = 0;
+					let _g1 = Project.projects;
+					while (_g < _g1.length) {
+						let p = _g1[_g];
+						++_g;
+						if (p.profiler != null) {
+							Fs.writeFileSync("whet-profile.json", JSON.stringify(p.profiler["export"](format), null, "  "));
+						};
+					};
+				};
+				process.on("exit", onExit);
+			};
 			let promises = [];
 			let _g = 0;
 			let _g1 = Project.projects;
@@ -131,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

@@ -1,3 +1,4 @@
+import {AnySpan} from "../profiler/Span"
 import {Cache, CacheDurability, DurabilityCheck} from "./Cache"
 import {AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
@@ -26,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>
@@ -47,4 +53,5 @@ export declare class BaseCache<Key, Value extends {
 	*/
 	protected replaceEntry(stone: AnyStone, existing: Value, replacement: Source): Promise<Value>
 	toString(): string
+	protected static setGenerateMeta(span: null | AnySpan, src: Source): void
 }