whet 0.0.33 → 0.1.0

package/bin/whet/SourceHash.js

@@ -13,7 +13,7 @@ const $global = Register.$global
 
 export const SourceHash = Register.global("$hxClasses")["whet.SourceHash"] = 
 class SourceHash extends Register.inherits() {
-	new(bytes) {
+	[Register.new](bytes) {
 		this.bytes = bytes;
 	}
 	add(hash) {
@@ -128,30 +128,37 @@ class SourceHash extends Register.inherits() {
 	* Only checks keys at root level, no deep inspection is done.
 	*/
 	static fromConfig(obj, ignoreList) {
-		let keys = [];
 		let _g = [];
 		let _g_keys = Reflect__1.fields(obj);
 		let _g_index = 0;
 		while (_g_index < _g_keys.length) {
 			let key = _g_keys[_g_index++];
-			let _g_value = obj[key];
-			let tmp;
 			switch (key) {
-				case "cacheStrategy":case "dependencies":case "id":case "project":
+				case "cacheStrategy":case "configStore":case "dependencies":case "id":case "project":
 					continue;
 					break
 				default:
 				if (ignoreList != null && ignoreList.includes(key)) {
 					continue;
-				} else {
-					keys.push(key);
-					tmp = (((_g_value) instanceof Stone)) ? _g_value.getHash() : (((_g_value) instanceof Router)) ? _g_value.getHash() : SourceHash.fromStringify(_g_value);
 				};
 				
 			};
-			_g.push(tmp);
+			_g.push(key);
 		};
-		return Promise.all(_g).then(function (hashes) {
+		_g.sort(Reflect__1.compare);
+		let _g1 = [];
+		let _g2 = 0;
+		while (_g2 < _g.length) {
+			let val = obj[_g[_g2++]];
+			if (((val) instanceof Stone)) {
+				_g1.push(val.getHash());
+			} else if (((val) instanceof Router)) {
+				_g1.push(val.getHash());
+			} else {
+				_g1.push(SourceHash.fromStringify(val));
+			};
+		};
+		return Promise.all(_g1).then(function (hashes) {
 			return SourceHash.merge(...hashes);
 		});
 	}
@@ -194,6 +201,7 @@ class SourceHash extends Register.inherits() {
 		return SourceHash
 	}
 }
+SourceHash.prototype.bytes = null;
 
 
 Register.createStatic(SourceHash, "EMPTY", function () { return (function($this) {var $r0

package/bin/whet/Stone.d.ts

@@ -5,6 +5,8 @@ import {CacheStrategy} from "./cache/Cache"
 import {SourceHash} from "./SourceHash"
 import {Source, SourceData} from "./Source"
 import {Project} from "./Project"
+import {ConfigStore} from "./ConfigStore"
+import {Buffer} from "buffer"
 
 export declare class Stone<T extends StoneConfig> {
 	constructor(config: T)
@@ -89,20 +91,50 @@ export declare class Stone<T extends StoneConfig> {
 	protected finalMaybeHash(): Promise<null | SourceHash>
 	
 	/**
-	* Abstract method.
-	* Function that actually generates the source. Passed hash is only non-null
-	* if `generateHash()` is implemented. It can be used for `CacheManager.getDir` and
-	* is passed mainly as optimization.
+	* Override to generate all source data at once. Passed hash is only non-null
+	* if `generateHash()` is implemented.
+	* Default implementation calls list() + generatePartial() for each ID.
+	* Stones must implement either this method or list() + generatePartial().
 	*/
 	protected generate(hash: SourceHash): Promise<SourceData[]>
 	
 	/**
-	* Returns a list of sources that this stone generates.
-	* Used by Router for finding the correct asset.
-	* Default implementation generates the sources to find their ids, but can be overriden
-	* to provide optimized implementation that would avoid generating assets we might not need.
+	* Optional override: return the list of output sourceIds this stone produces,
+	* without triggering generation. Return null if unknown (default).
+	* Used by cache for partial entry completion and by listIds() as fast path.
 	*/
-	list(): Promise<string[]>
+	protected list(): Promise<null | string[]>
+	
+	/**
+	* Public API for getting output IDs. Calls list(), falls back to
+	* full generation if list() returns null.
+	*/
+	listIds(): Promise<string[]>
+	
+	/**
+	* Optional override for partial generation.
+	* Called when a single output is requested via getPartialSource().
+	* Return data for the requested sourceId, or null to signal
+	* "not supported" (triggers fallback to full generation + filter).
+	*/
+	protected generatePartial(sourceId: string, hash: SourceHash): Promise<null | SourceData[]>
+	
+	/**
+	* Get source for a single output by sourceId.
+	* If the stone implements generatePartial(), generates just the requested output.
+	* Otherwise falls back to full generation + filter.
+	* Uses the same cache as getSource() — partial and full share the pool.
+	*/
+	getPartialSource(sourceId: string): Promise<null | Source>
+	
+	/**
+	* Called by cache infrastructure. Generates partial source directly,
+	* never goes back through cache methods.
+	*/
+	protected generatePartialSource(sourceId: string, hash: SourceHash): Promise<{
+		complete: boolean, 
+		source: Source
+	}>
 	
 	/**
 	* Optional filter describing what this Stone can produce.
@@ -132,6 +164,21 @@ export declare class Stone<T extends StoneConfig> {
 	*/
 	exportTo(path: string): Promise<any>
 	
+	/**
+	Get the raw Buffer of the first (or only) output.
+	*/
+	getData(): Promise<Buffer>
+	
+	/**
+	Get the first (or only) output as a UTF-8 string.
+	*/
+	getString(): Promise<string>
+	
+	/**
+	Get the first (or only) output parsed as JSON.
+	*/
+	getJson(): Promise<any>
+	
 	/**
 	* Convenient function to get CWD-relative path from project-relative one.
 	* Useful for pure JS stones.
@@ -149,6 +196,10 @@ export type StoneConfig = {
 	*/
 	cacheStrategy?: null | CacheStrategy, 
 	/**
+	Optional ConfigStore for persistent per-stone config patching. Overrides project-level configStore.
+	*/
+	configStore?: null | ConfigStore, 
+	/**
 	* Registers another stone(s) as dependency of this one. Useful for external processes
 	* that use a source of some stone, but don't go via Whet to get it.
 	* Use with combination of `setAbsolutePath` on the dependency, so that the external process

package/bin/whet/Stone.js

@@ -14,7 +14,7 @@ const $global = Register.$global
 
 export const Stone = Register.global("$hxClasses")["whet.Stone"] = 
 class Stone extends Register.inherits() {
-	new(config) {
+	[Register.new](config) {
 		this.locked = false;
 		this.lockQueue = [];
 		this.ignoreFileHash = false;
@@ -27,9 +27,27 @@ class Stone extends Register.inherits() {
 		if (this.project == null) {
 			throw new Error("Did not find a project. Create one before creating stones.");
 		};
-		this.project.stones.push(this);
 		this.initConfig();
-		this.id = (config.id != null) ? StoneId_Fields_.makeStoneId(config.id) : StoneId_Fields_.makeStoneId(this);
+		let isExplicitId = config.id != null;
+		this.id = (isExplicitId) ? StoneId_Fields_.makeStoneId(config.id) : StoneId_Fields_.makeStoneId(this);
+		let duplicates = 0;
+		let _g = 0;
+		let _g1 = this.project.stones;
+		while (_g < _g1.length) {
+			let stone = _g1[_g];
+			++_g;
+			if (stone.id == this.id || !isExplicitId && stone.id != null && stone.id.startsWith(this.id + ":")) {
+				++duplicates;
+			};
+		};
+		if (duplicates > 0) {
+			if (isExplicitId) {
+				Log.log(40, ...["Duplicate explicit Stone ID.", {"id": this.id}]);
+			} else {
+				this.id = this.id + ":" + (duplicates + 1);
+			};
+		};
+		this.project.stones.push(this);
 		this.cacheStrategy = (config.cacheStrategy == null) ? this.project.cache.defaultStrategy : config.cacheStrategy;
 		this.addCommands();
 	}
@@ -215,29 +233,139 @@ class Stone extends Register.inherits() {
 	* dependencies.
 	*/
 	finalMaybeHash() {
+		let tmp = this.config.configStore;
+		let store = (tmp != null) ? tmp : this.project.configStore;
+		let patchPromise = (store != null) ? store.ensureApplied(this) : Promise.resolve(null);
+		let _gthis = this;
+		return patchPromise.then(function (_) {
+			return _gthis.generateHash().then(function (hash) {
+				return _gthis.finalizeHash(hash);
+			});
+		});
+	}
+	
+	/**
+	* Override to generate all source data at once. Passed hash is only non-null
+	* if `generateHash()` is implemented.
+	* Default implementation calls list() + generatePartial() for each ID.
+	* Stones must implement either this method or list() + generatePartial().
+	*/
+	generate(hash) {
 		let _gthis = this;
-		return this.generateHash().then(function (hash) {
-			return _gthis.finalizeHash(hash);
+		return this.list().then(function (ids) {
+			if (ids == null) {
+				throw new Error("Stone must implement either generate() or list() + generatePartial().");
+			};
+			let _g = [];
+			let _g1 = 0;
+			while (_g1 < ids.length) _g.push(_gthis.generatePartial(ids[_g1++], hash));
+			return Promise.all(_g).then(function (results) {
+				let all = [];
+				let _g = 0;
+				while (_g < results.length) {
+					let r = results[_g];
+					++_g;
+					if (r != null) {
+						let _g = 0;
+						while (_g < r.length) all.push(r[_g++]);
+					};
+				};
+				return all;
+			});
 		});
 	}
 	
 	/**
-	* Returns a list of sources that this stone generates.
-	* Used by Router for finding the correct asset.
-	* Default implementation generates the sources to find their ids, but can be overriden
-	* to provide optimized implementation that would avoid generating assets we might not need.
+	* Optional override: return the list of output sourceIds this stone produces,
+	* without triggering generation. Return null if unknown (default).
+	* Used by cache for partial entry completion and by listIds() as fast path.
 	*/
 	list() {
-		return this.getSource().then(function (source) {
-			let _this = source.data;
-			let result = new Array(_this.length);
-			let _g = 0;
-			let _g1 = _this.length;
-			while (_g < _g1) {
-				let i = _g++;
-				result[i] = _this[i].id;
+		return Promise.resolve(null);
+	}
+	
+	/**
+	* Public API for getting output IDs. Calls list(), falls back to
+	* full generation if list() returns null.
+	*/
+	listIds() {
+		let _gthis = this;
+		return this.list().then(function (ids) {
+			if (ids != null) {
+				return ids;
 			};
-			return result;
+			return _gthis.getSource().then(function (source) {
+				let _this = source.data;
+				let result = new Array(_this.length);
+				let _g = 0;
+				let _g1 = _this.length;
+				while (_g < _g1) {
+					let i = _g++;
+					result[i] = _this[i].id;
+				};
+				return result;
+			});
+		});
+	}
+	
+	/**
+	* Optional override for partial generation.
+	* Called when a single output is requested via getPartialSource().
+	* Return data for the requested sourceId, or null to signal
+	* "not supported" (triggers fallback to full generation + filter).
+	*/
+	generatePartial(sourceId, hash) {
+		return Promise.resolve(null);
+	}
+	
+	/**
+	* Get source for a single output by sourceId.
+	* If the stone implements generatePartial(), generates just the requested output.
+	* Otherwise falls back to full generation + filter.
+	* Uses the same cache as getSource() — partial and full share the pool.
+	*/
+	getPartialSource(sourceId) {
+		let _gthis = this;
+		return this.finalMaybeHash().then(function (hash) {
+			if (hash == null) {
+				return _gthis.getSource().then(function (source) {
+					return source.filterTo(sourceId);
+				});
+			} else {
+				return _gthis.project.cache.getPartialSource(_gthis, sourceId);
+			};
+		});
+	}
+	
+	/**
+	* Called by cache infrastructure. Generates partial source directly,
+	* never goes back through cache methods.
+	*/
+	generatePartialSource(sourceId, hash) {
+		if (!this.locked) {
+			throw new Error("Acquire a lock before generating.");
+		};
+		let init;
+		if (this.config.dependencies != 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);
+		} else {
+			init = Promise.resolve(null);
+		};
+		let _gthis = this;
+		return init.then(function (_) {
+			return _gthis.generatePartial(sourceId, hash).then(function (data) {
+				if (data != null) {
+					return {"source": new Source(data, hash, _gthis, Date.now() / 1000, false), "complete": false};
+				} else {
+					return _gthis.generate(hash).then(function (allData) {
+						return {"source": new Source(allData, hash, _gthis, Date.now() / 1000, true), "complete": true};
+					});
+				};
+			});
 		});
 	}
 	
@@ -309,6 +437,33 @@ class Stone extends Register.inherits() {
 		});
 	}
 	
+	/**
+	Get the raw Buffer of the first (or only) output.
+	*/
+	getData() {
+		return this.getSource().then(function (s) {
+			return s.get().data;
+		});
+	}
+	
+	/**
+	Get the first (or only) output as a UTF-8 string.
+	*/
+	getString() {
+		return this.getData().then(function (d) {
+			return d.toString("utf-8");
+		});
+	}
+	
+	/**
+	Get the first (or only) output parsed as JSON.
+	*/
+	getJson() {
+		return this.getString().then(function (s) {
+			return JSON.parse(s);
+		});
+	}
+	
 	/**
 	* Convenient function to get CWD-relative path from project-relative one.
 	* Useful for pure JS stones.
@@ -329,4 +484,11 @@ class Stone extends Register.inherits() {
 		return Stone
 	}
 }
+Stone.prototype.config = null;
+Stone.prototype.ignoreFileHash = null;
+Stone.prototype.id = null;
+Stone.prototype.cacheStrategy = null;
+Stone.prototype.project = null;
+Stone.prototype.lockQueue = null;
+Stone.prototype.locked = null;
 

package/bin/whet/Whet.d.ts

@@ -2,4 +2,3 @@ import {Command} from "commander"
 
 export const program: Command
 export const main: () => void
-export const executeCommand: (cmd: string[]) => Promise<Command>

package/bin/whet/Whet.js

@@ -1,9 +1,10 @@
 import {Project} from "./Project.js"
 import {LogLevel, Log} from "./Log.js"
 import * as Url from "url"
-import * as PinoPretty from "pino-pretty"
+import PinoPretty from "pino-pretty"
 import {Exception} from "../haxe/Exception.js"
 import {Register} from "../genes/Register.js"
+import * as Fs from "fs"
 import {Command, CommanderError} from "commander"
 import {Std} from "../Std.js"
 
@@ -12,12 +13,25 @@ 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.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();
+		let tmp = process.argv[1];
+		let argv1 = (tmp != null) ? tmp : "";
+		let realArgv1;
+		try {
+			realArgv1 = Fs.realpathSync(argv1);
+		}catch (_g) {
+			realArgv1 = argv1;
+		};
+		let entryUrl = Url.pathToFileURL(realArgv1).href;
+		let thisUrl = new URL('../whet.js',import.meta.url).href;
+		if (entryUrl != thisUrl) {
+			return;
+		};
+		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.1.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").exitOverride();
 		try {
 			Whet_Fields_.program.parse();
 		}catch (_g) {
 			let _g1 = Exception.caught(_g);
-			if (((_g1.get_native()) instanceof CommanderError) && _g1.get_native().code == "commander.version") {
+			if (((_g1.get_native()) instanceof CommanderError) && (_g1.get_native().code == "commander.version" || _g1.get_native().code == "commander.helpDisplayed")) {
 				process.exit();
 			} else {
 				throw Exception.thrown(_g1);
@@ -36,7 +50,7 @@ class Whet_Fields_ {
 			};
 		};
 		if (options.pretty) {
-			Log.stream = PinoPretty["default"]();
+			Log.stream = PinoPretty();
 		};
 		global.setImmediate(Whet_Fields_.init, options);
 	}
@@ -117,18 +131,16 @@ class Whet_Fields_ {
 			nextCommand();
 		});
 	}
-	static executeCommand(cmd) {
-		Log.log(10, ...["Executing command.", {"command": cmd}]);
-		return Whet_Fields_.program.parseAsync(cmd, {"from": "user"});
-	}
 	static getCommands(args) {
 		let commands = [];
 		let from = 0;
 		let to;
 		do {
-			to = args.indexOf("+", from);
-			commands.push((to < 0) ? args.slice(from) : args.slice(from, to));
-			from = to + 1;
+			{
+				to = args.indexOf("+", from);
+				commands.push((to < 0) ? args.slice(from) : args.slice(from, to));
+				from = to + 1;
+			}
 		} while (to >= 0);
 		return commands;
 	}
@@ -144,4 +156,3 @@ class Whet_Fields_ {
 Whet_Fields_.program = new Command("whet")
 export const program = Whet_Fields_.program
 export const main = Whet_Fields_.main
-export const executeCommand = Whet_Fields_.executeCommand

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

@@ -5,6 +5,7 @@ import {Source} from "../Source"
 import {Map as Map__1} from "../../Map"
 
 export declare class BaseCache<Key, Value extends {
+	complete: boolean, 
 	ctime: number, 
 	hash: SourceHash
 }> implements Cache {
@@ -12,8 +13,15 @@ export declare class BaseCache<Key, Value extends {
 	protected cache: Map__1<Key, Value[]>
 	protected rootDir: string
 	get(stone: AnyStone, durability: CacheDurability, check: DurabilityCheck): Promise<Source>
+	getPartial(stone: AnyStone, sourceId: string, durability: CacheDurability, check: DurabilityCheck): Promise<null | Source>
 	protected set(source: Source): Promise<Value>
 	getUniqueDir(stone: AnyStone, baseDir: string, hash?: null | SourceHash): string
+	
+	/**
+	* Complete a partial cache entry. Tries list() for incremental completion,
+	* falls back to full generateSource() if list() returns null.
+	*/
+	protected completePartialEntry(stone: AnyStone, existing: Value, hash: SourceHash): Promise<Value>
 	protected checkDurability(stone: AnyStone, values: Value[], durability: CacheDurability, useIndex: ((arg0: Value) => number), ageIndex: ((arg0: Value) => number)): void
 	protected shouldKeep(stone: AnyStone, val: Value, durability: CacheDurability, useIndex: ((arg0: Value) => number), ageIndex: ((arg0: Value) => number)): boolean
 	protected setRecentUseOrder(values: Value[], value: Value): boolean
@@ -23,5 +31,20 @@ export declare class BaseCache<Key, Value extends {
 	protected source(stone: AnyStone, value: Value): Promise<Source>
 	protected getExistingDirs(stone: AnyStone): string[]
 	protected getDirFor(value: Value): string
+	
+	/**
+	Check if entry contains a specific sourceId.
+	*/
+	protected hasSourceId(value: Value, sourceId: string): boolean
+	
+	/**
+	Merge partial source data into an existing entry, returns the updated value.
+	*/
+	protected mergePartial(stone: AnyStone, existing: Value, addition: Source, markComplete: boolean): Promise<Value>
+	
+	/**
+	Replace an existing entry with a new complete source.
+	*/
+	protected replaceEntry(stone: AnyStone, existing: Value, replacement: Source): Promise<Value>
 	toString(): string
 }

package/bin/whet/cache/BaseCache.js

@@ -12,7 +12,7 @@ const $global = Register.$global
 
 export const BaseCache = Register.global("$hxClasses")["whet.cache.BaseCache"] = 
 class BaseCache extends Register.inherits() {
-	new(rootDir, cache) {
+	[Register.new](rootDir, cache) {
 		let id = rootDir;
 		if (!(id.length == 0 || id.charCodeAt(id.length - 1) == 47)) {
 			throw new Error("Root dir is a not a dir.");
@@ -80,6 +80,11 @@ class BaseCache extends Register.inherits() {
 								return _gthis.source(stone, val);
 							});
 						});
+					} else if (!src.complete) {
+						Log.log(10, ...["Found partial entry in cache, completing.", {"stone": stone, "cache": _gthis}]);
+						return _gthis.completePartialEntry(stone, value, hash).then(function (val) {
+							return _gthis.source(stone, val);
+						});
 					} else {
 						Log.log(10, ...["Found in cache", {"stone": stone, "cache": _gthis}]);
 						return Promise.resolve(src);
@@ -96,6 +101,50 @@ class BaseCache extends Register.inherits() {
 			});
 		});
 	}
+	getPartial(stone, sourceId, durability, check) {
+		let _gthis = this;
+		return stone.acquire(function () {
+			return stone.finalMaybeHash().then(function (hash) {
+				let values = _gthis.cache.get(_gthis.key(stone));
+				let value = null;
+				if (values != null && values.length > 0) {
+					value = Lambda.find(values, function (v) {
+						return SourceHash.equals(v.hash, hash);
+					});
+					if (value != null) {
+						_gthis.setRecentUseOrder(values, value);
+					};
+				};
+				if (value != null && _gthis.hasSourceId(value, sourceId)) {
+					return _gthis.source(stone, value).then(function (src) {
+						if (src != null) {
+							return src.filterTo(sourceId);
+						} else {
+							return null;
+						};
+					});
+				} else if (value != null && value.complete) {
+					return Promise.resolve(null);
+				} else {
+					return stone.generatePartialSource(sourceId, hash).then(function (result) {
+						if (result.complete) {
+							return ((value != null) ? _gthis.replaceEntry(stone, value, result.source) : _gthis.set(result.source)).then(function (_) {
+								return result.source.filterTo(sourceId);
+							});
+						} else if (value != null) {
+							return _gthis.mergePartial(stone, value, result.source, false).then(function (_) {
+								return result.source.filterTo(sourceId);
+							});
+						} else {
+							return _gthis.set(result.source).then(function (_) {
+								return result.source.filterTo(sourceId);
+							});
+						};
+					});
+				};
+			});
+		});
+	}
 	set(source) {
 		Log.log(10, ...["Setting source in cache.", {"source": source}]);
 		let k = this.key(source.origin);
@@ -137,6 +186,47 @@ class BaseCache extends Register.inherits() {
 		};
 		return Path.posix.join(baseDir, "v" + maxNum + "/");
 	}
+	
+	/**
+	* Complete a partial cache entry. Tries list() for incremental completion,
+	* falls back to full generateSource() if list() returns null.
+	*/
+	completePartialEntry(stone, existing, hash) {
+		let _gthis = this;
+		return stone.list().then(function (allIds) {
+			if (allIds != null) {
+				let _g = [];
+				let _g1 = 0;
+				while (_g1 < allIds.length) {
+					let v = allIds[_g1];
+					++_g1;
+					if (!_gthis.hasSourceId(existing, v)) {
+						_g.push(v);
+					};
+				};
+				if (_g.length == 0) {
+					return _gthis.mergePartial(stone, existing, null, true);
+				};
+				let chain = Promise.resolve(existing);
+				let _g2 = 0;
+				while (_g2 < _g.length) {
+					let missingId = _g[_g2++];
+					chain = chain.then(function (current) {
+						return stone.generatePartialSource(missingId, hash).then(function (result) {
+							return _gthis.mergePartial(stone, current, result.source, false);
+						});
+					});
+				};
+				return chain.then(function (current) {
+					return _gthis.mergePartial(stone, current, null, true);
+				});
+			} else {
+				return stone.generateSource(hash).then(function (fullSource) {
+					return _gthis.replaceEntry(stone, existing, fullSource);
+				});
+			};
+		});
+	}
 	checkDurability(stone, values, durability, useIndex, ageIndex) {
 		Log.log(20, ...["Checking durability.", {"stone": stone, "durability": Std.string(durability)}]);
 		if (values == null || values.length == 0) {
@@ -205,4 +295,6 @@ class BaseCache extends Register.inherits() {
 		return BaseCache
 	}
 }
+BaseCache.prototype.cache = null;
+BaseCache.prototype.rootDir = null;
 

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

@@ -18,6 +18,7 @@ export declare class CacheManager {
 	*/
 	defaultFileStrategy: CacheStrategy
 	getSource(stone: AnyStone): Promise<Source>
+	getPartialSource(stone: AnyStone, sourceId: string): Promise<null | Source>
 	
 	/**
 	* Re-generates source even if the currently cached value is valid.
@@ -30,4 +31,5 @@ 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
+	close(): Promise<void>
 }