whet 0.5.0 → 0.6.0

package/bin/whet/ConfigStore.js

@@ -1,6 +1,4 @@
-import {Router} from "./route/Router.js"
 import {Utils} from "./Utils.js"
-import {Stone} from "./Stone.js"
 import * as Path from "path"
 import {Register} from "../genes/Register.js"
 import * as Fs from "fs"
@@ -250,16 +248,16 @@ class ConfigStore extends Register.inherits() {
 		if (val == null) {
 			return true;
 		};
-		if (((val) instanceof Stone)) {
+		if (typeof val === "function") {
 			return false;
 		};
-		if (((val) instanceof Router)) {
-			return false;
+		if (typeof val !== "object") {
+			return true;
 		};
-		if (typeof val === "function") {
-			return false;
+		if (((val) instanceof Array)) {
+			return true;
 		};
-		return true;
+		return (Object.getPrototypeOf(val) === null || Object.getPrototypeOf(val) === Object.prototype);
 	}
 	static deepClone(val) {
 		if (val == null) {

package/bin/whet/Log.js

@@ -72,7 +72,7 @@ class Log {
 
 
 Log.logLevel = 30
-Log.stream = process.stdout
+Log.stream = process.stderr
 export const LogLevel = Register.global("$hxClasses")["whet._Log.LogLevel"] = 
 class LogLevel {
 	static fromString(s) {

package/bin/whet/Stone.d.ts

@@ -17,6 +17,12 @@ export declare class Stone<T extends StoneConfig> {
 	If true, hash of a cached file (not `stone.getHash()` but actual file contents) won't be checked.
 	*/
 	ignoreFileHash: boolean
+	
+	/**
+	* If true, this stone's own method source code is excluded from its hash (opt out of the
+	* code-aware self-hash). Only relevant for stones that override `generateHash()`. See `codeHash`.
+	*/
+	ignoreCodeHash: boolean
 	id: string
 	cacheStrategy: CacheStrategy
 	readonly cache: CacheManager
@@ -89,6 +95,10 @@ export declare class Stone<T extends StoneConfig> {
 	* **Do not override.**
 	* Used by cache. Returns either null, or result of `generateHash` finalized by adding
 	* dependencies.
+	*
+	* When `generateHash()` returns a non-null hash, the stone's own code hash (`codeHash`) is mixed
+	* in, so editing the stone's generation logic busts the cache even though config/inputs are
+	* unchanged.
 	*/
 	protected finalMaybeHash(): Promise<null | SourceHash>
 	
@@ -108,8 +118,9 @@ export declare class Stone<T extends StoneConfig> {
 	protected list(): Promise<null | string[]>
 	
 	/**
-	* Public API for getting output IDs. Calls list(), falls back to
-	* full generation if list() returns null.
+	* Public API for getting output IDs. Calls list(); if that returns null, tries the cache
+	* metadata fast path (`cache.tryListIds`, zero file reads / zero generation); only if the cache
+	* can't answer does it fall back to a full `getSource()`.
 	*/
 	listIds(): Promise<string[]>
 	
@@ -255,6 +266,34 @@ export declare class Stone<T extends StoneConfig> {
 	protected profilerGetCurrentSpan(): null | AnySpan
 	protected get_cache(): CacheManager
 	toString(): string
+	
+	/**
+	Per-class memo for `codeHash`, keyed by constructor. Computed once per process per class.
+	*/
+	protected static codeHashCache: Map<any, SourceHash>
+	
+	/**
+	* Hash of the stone class's own source: `Function.prototype.toString()` of *every* own method
+	* (instance/prototype methods, accessors, and static methods) defined on the stone's class and
+	* its ancestors down to — but excluding — `Stone` itself. Memoized per class.
+	
+	*
+	* **Limitations** (not reachable by reflection from the class object): does NOT capture changes
+	* in *module-level free functions* in the same file, nor in *imported helper modules* a method
+	* delegates to. Only class-level methods (instance + static) participate; instance-own function
+	* properties are intentionally excluded so the per-class memo stays sound.
+	*/
+	protected static codeHash(stone: AnyStone): SourceHash
+	protected static ownsFinalizeHash(obj: any): boolean
+	
+	/**
+	* Appends `name:slot:source` for every own function-valued slot (`value`/`get`/`set`) of `obj`'s
+	* own properties to `parts`, sorted by name for determinism. Uses property descriptors so getters
+	* and setters are read by source rather than invoked. Skips `constructor` and Haxe-internal
+	* bookkeeping props (`__class__`, `__super__`, `__name__`, …) — those aren't stone logic and
+	* `__super__` would otherwise pull the parent class's source into every subclass's hash.
+	*/
+	protected static collectOwnFunctions(obj: any, parts: string[]): void
 }
 
 export type StoneConfig = {

package/bin/whet/Stone.js

@@ -10,6 +10,7 @@ import {Project} from "./Project.js"
 import {Log} from "./Log.js"
 import * as Path from "path"
 import {Register} from "../genes/Register.js"
+import {Reflect as Reflect__1} from "../Reflect.js"
 
 const $global = Register.$global
 
@@ -19,6 +20,7 @@ class Stone extends Register.inherits() {
 		this._contextPromise = null;
 		this.locked = false;
 		this.lockQueue = [];
+		this.ignoreCodeHash = false;
 		this.ignoreFileHash = false;
 		Log.log(10, ...["Instantiating new Stone.", {"type": StoneId_Fields_.getTypeName(this)}]);
 		if (config == null) {
@@ -310,6 +312,10 @@ class Stone extends Register.inherits() {
 	* **Do not override.**
 	* Used by cache. Returns either null, or result of `generateHash` finalized by adding
 	* dependencies.
+	*
+	* When `generateHash()` returns a non-null hash, the stone's own code hash (`codeHash`) is mixed
+	* in, so editing the stone's generation logic busts the cache even though config/inputs are
+	* unchanged.
 	*/
 	finalMaybeHash() {
 		let tmp = this.config.configStore;
@@ -318,6 +324,9 @@ class Stone extends Register.inherits() {
 		let _gthis = this;
 		return patchPromise.then(function (_) {
 			return _gthis.generateHash().then(function (hash) {
+				if (hash != null && !_gthis.ignoreCodeHash) {
+					hash = hash.add(Stone.codeHash(_gthis));
+				};
 				return _gthis.finalizeHash(hash);
 			});
 		});
@@ -364,8 +373,9 @@ class Stone extends Register.inherits() {
 	}
 	
 	/**
-	* Public API for getting output IDs. Calls list(), falls back to
-	* full generation if list() returns null.
+	* Public API for getting output IDs. Calls list(); if that returns null, tries the cache
+	* metadata fast path (`cache.tryListIds`, zero file reads / zero generation); only if the cache
+	* can't answer does it fall back to a full `getSource()`.
 	*/
 	listIds() {
 		let _gthis = this;
@@ -373,16 +383,21 @@ class Stone extends Register.inherits() {
 			if (ids != null) {
 				return ids;
 			};
-			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 _gthis.project.cache.tryListIds(_gthis).then(function (cachedIds) {
+				if (cachedIds != null) {
+					return cachedIds;
 				};
-				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;
+				});
 			});
 		});
 	}
@@ -701,6 +716,83 @@ class Stone extends Register.inherits() {
 	toString() {
 		return "" + this.id + ":" + StoneId_Fields_.getTypeName(this);
 	}
+	
+	/**
+	* Hash of the stone class's own source: `Function.prototype.toString()` of *every* own method
+	* (instance/prototype methods, accessors, and static methods) defined on the stone's class and
+	* its ancestors down to — but excluding — `Stone` itself. Memoized per class.
+	
+	*
+	* **Limitations** (not reachable by reflection from the class object): does NOT capture changes
+	* in *module-level free functions* in the same file, nor in *imported helper modules* a method
+	* delegates to. Only class-level methods (instance + static) participate; instance-own function
+	* properties are intentionally excluded so the per-class memo stays sound.
+	*/
+	static codeHash(stone) {
+		let ctor = stone.constructor;
+		let cached = Stone.codeHashCache.get(ctor);
+		if (cached != null) {
+			return cached;
+		};
+		let parts = [];
+		let proto = Object.getPrototypeOf(stone);
+		while (proto != null && !Object.prototype.hasOwnProperty.call(proto, 'finalizeHash')) {
+			Stone.collectOwnFunctions(proto, parts);
+			proto = Object.getPrototypeOf(proto);
+		};
+		let funcProto = Function.prototype;
+		let klass = ctor;
+		while (klass != null && klass != funcProto) {
+			let kproto = klass.prototype;
+			if (kproto != null && Object.prototype.hasOwnProperty.call(kproto, 'finalizeHash')) {
+				break;
+			};
+			Stone.collectOwnFunctions(klass, parts);
+			klass = Object.getPrototypeOf(klass);
+		};
+		let hash = SourceHash.fromString(parts.join("\n"));
+		Stone.codeHashCache.set(ctor, hash);
+		return hash;
+	}
+	static ownsFinalizeHash(obj) {
+		return Object.prototype.hasOwnProperty.call(obj, 'finalizeHash');
+	}
+	
+	/**
+	* Appends `name:slot:source` for every own function-valued slot (`value`/`get`/`set`) of `obj`'s
+	* own properties to `parts`, sorted by name for determinism. Uses property descriptors so getters
+	* and setters are read by source rather than invoked. Skips `constructor` and Haxe-internal
+	* bookkeeping props (`__class__`, `__super__`, `__name__`, …) — those aren't stone logic and
+	* `__super__` would otherwise pull the parent class's source into every subclass's hash.
+	*/
+	static collectOwnFunctions(obj, parts) {
+		let names = Object.getOwnPropertyNames(obj);
+		names.sort(Reflect__1.compare);
+		let _g = 0;
+		while (_g < names.length) {
+			let name = names[_g];
+			++_g;
+			if (name == "constructor" || name.startsWith("__")) {
+				continue;
+			};
+			let desc = Object.getOwnPropertyDescriptor(obj, name);
+			if (desc == null) {
+				continue;
+			};
+			let fn = desc["value"];
+			if (fn != null && typeof fn === 'function') {
+				parts.push(name + ":" + "value" + ":" + Function.prototype.toString.call(fn));
+			};
+			let fn1 = desc["get"];
+			if (fn1 != null && typeof fn1 === 'function') {
+				parts.push(name + ":" + "get" + ":" + Function.prototype.toString.call(fn1));
+			};
+			let fn2 = desc["set"];
+			if (fn2 != null && typeof fn2 === 'function') {
+				parts.push(name + ":" + "set" + ":" + Function.prototype.toString.call(fn2));
+			};
+		};
+	}
 	static get __name__() {
 		return "whet.Stone"
 	}
@@ -710,6 +802,7 @@ class Stone extends Register.inherits() {
 }
 Stone.prototype.config = null;
 Stone.prototype.ignoreFileHash = null;
+Stone.prototype.ignoreCodeHash = null;
 Stone.prototype.id = null;
 Stone.prototype.cacheStrategy = null;
 Stone.prototype.project = null;
@@ -717,3 +810,5 @@ Stone.prototype.lockQueue = null;
 Stone.prototype.locked = null;
 Stone.prototype._contextPromise = null;
 
+
+Stone.codeHashCache = new Map()

package/bin/whet/Whet.d.ts

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

package/bin/whet/Whet.js

@@ -5,7 +5,7 @@ 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 {Command, Option, CommanderError} from "commander"
 import {Std} from "../Std.js"
 
 const $global = Register.$global
@@ -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.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();
+		Whet_Fields_.program.enablePositionalOptions().passThroughOptions().description("Project tooling.").usage("[options] [command] [+ [command]...]").version("0.6.0", "-v, --version").allowUnknownOption(true).allowExcessArguments(true).showSuggestionAfterError(true).helpOption(false).option("-p, --project <file>", "project to run", "Project.mjs").addOption(new Option("-l, --log-level <level>", "log level, a string/number")["default"]("info").env("WHET_LOG_LEVEL")).option("--no-pretty", "disable pretty logging").option("-q, --quiet", "quiet output: warn level + no color (the default when stdout is not a TTY)").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) {
@@ -37,6 +37,8 @@ class Whet_Fields_ {
 				throw Exception.thrown(_g1);
 			};
 		};
+		let firstSegment = Whet_Fields_.getCommands(Whet_Fields_.program.args)[0];
+		Whet_Fields_.topLevelHelp = firstSegment.length > 0 && (firstSegment[0] == "--help" || firstSegment[0] == "-h");
 		let options = Whet_Fields_.program.opts();
 		if (options.logLevel != null) {
 			let n = Std.parseInt(options.logLevel);
@@ -49,8 +51,14 @@ class Whet_Fields_ {
 				Log.logLevel = n;
 			};
 		};
-		if (options.pretty) {
-			Log.stream = PinoPretty();
+		let nonTty = process.stdout.isTTY != true;
+		let levelSource = Whet_Fields_.program.getOptionValueSource("logLevel");
+		let prettySource = Whet_Fields_.program.getOptionValueSource("pretty");
+		if (options.quiet || nonTty && levelSource == "default") {
+			Log.logLevel = 40;
+		};
+		if ((options.quiet) ? false : (prettySource != "default") ? options.pretty : !nonTty) {
+			Log.stream = PinoPretty({"destination": 2});
 		};
 		global.setImmediate(Whet_Fields_.init, options);
 	}
@@ -66,9 +74,11 @@ class Whet_Fields_ {
 				Log.log(10, ...["Project module imported."]);
 				Whet_Fields_.initProjects();
 			})["catch"](function (e) {
-				Log.log(50, ...["Error loading project.", {"error": e}]);
-				if (((e) instanceof Error)) {
-					Log.log(50, ...[e.stack]);
+				if (!Whet_Fields_.topLevelHelp) {
+					Log.log(50, ...["Error loading project.", {"error": e}]);
+					if (((e) instanceof Error)) {
+						Log.log(50, ...[e.stack]);
+					};
 				};
 				try {
 					Whet_Fields_.program.help();
@@ -87,6 +97,7 @@ class Whet_Fields_ {
 			while (_g2 < _g3.length) Whet_Fields_.program.addOption(_g3[_g2++]);
 		};
 		Whet_Fields_.program.allowUnknownOption(false);
+		Whet_Fields_.program.helpOption("-h, --help", "display help for command");
 		let schemaCmd = new Command("schema");
 		schemaCmd.description("Export project schema as JSON.");
 		schemaCmd.action(Whet_Fields_.outputSchema);
@@ -144,7 +155,7 @@ class Whet_Fields_ {
 			Whet_Fields_.program.parseAsync(c, {"from": "user"}).then(function (_) {
 				nextCommand();
 			})["catch"](function (err) {
-				if (((err) instanceof CommanderError) && err.code == "commander.help") {
+				if (((err) instanceof CommanderError) && (err.code == "commander.help" || err.code == "commander.helpDisplayed")) {
 					return;
 				};
 				Log.log(50, ...["Error while executing command.", {"error": err}]);
@@ -188,6 +199,9 @@ class Whet_Fields_ {
 	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 serializeArgument(arg) {
+		return {"name": arg.name(), "description": arg.description, "choices": arg.argChoices, "defaultValue": arg.defaultValue, "required": arg.required, "variadic": arg.variadic};
+	}
 	static serializeCommand(cmd) {
 		let tmp = cmd.name();
 		let tmp1 = cmd.description();
@@ -196,7 +210,11 @@ class Whet_Fields_ {
 		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};
+		let _g3 = [];
+		let _g4 = 0;
+		let _g5 = cmd.registeredArguments;
+		while (_g4 < _g5.length) _g3.push(Whet_Fields_.serializeArgument(_g5[_g4++]));
+		return {"name": tmp, "description": tmp1, "aliases": tmp2, "options": _g, "arguments": _g3};
 	}
 	static getCommands(args) {
 		let commands = [];
@@ -221,5 +239,6 @@ class Whet_Fields_ {
 
 
 Whet_Fields_.program = new Command("whet")
+Whet_Fields_.topLevelHelp = false
 export const program = Whet_Fields_.program
 export const main = Whet_Fields_.main

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

@@ -15,6 +15,20 @@ export declare class BaseCache<Key, Value extends {
 	protected rootDir: string
 	get(stone: AnyStone, durability: CacheDurability, check: DurabilityCheck): Promise<Source>
 	getPartial(stone: AnyStone, sourceId: string, durability: CacheDurability, check: DurabilityCheck): Promise<null | Source>
+	
+	/**
+	* Enumerate a stone's output ids from cache metadata alone — no file reads, no generation.
+	* Used by `Stone.listIds()` as a fast path before falling back to a full `getSource()`.
+	*
+	* Returns null (caller falls back) unless there is a *complete* entry whose hash matches the
+	* stone's current `finalMaybeHash()`. Sound because the output id-set is a pure function of that
+	* hash, so a complete matching entry's files are the authoritative id list. Stale/missing files
+	* on disk are irrelevant here — they're stat-validated (and regenerated) when actually fetched.
+	*
+	* Intentionally takes no lock and does not touch use-order/durability: listing is a read-only
+	* "what does this produce" query, not a use of the cached bytes.
+	*/
+	tryListIds(stone: AnyStone): Promise<null | string[]>
 	protected set(source: Source): Promise<Value>
 	getUniqueDir(stone: AnyStone, baseDir: string, hash?: null | SourceHash): string
 	
@@ -35,6 +49,13 @@ export declare class BaseCache<Key, Value extends {
 	protected key(stone: AnyStone): Key
 	protected value(source: Source): Promise<Value>
 	protected source(stone: AnyStone, value: Value): Promise<Source>
+	
+	/**
+	* Read & validate just the requested file from an entry, without touching the rest. Resolves
+	* the single-output Source when valid, or null when that file is invalid/missing (the caller
+	* then regenerates it).
+	*/
+	protected sourcePartial(stone: AnyStone, value: Value, sourceId: string): Promise<null | Source>
 	protected getExistingDirs(stone: AnyStone): string[]
 	protected getDirFor(value: Value): string
 	
@@ -43,6 +64,11 @@ export declare class BaseCache<Key, Value extends {
 	*/
 	protected hasSourceId(value: Value, sourceId: string): boolean
 	
+	/**
+	All output ids held by an entry, read from metadata without touching files.
+	*/
+	protected getValueIds(value: Value): string[]
+	
 	/**
 	Merge partial source data into an existing entry, returns the updated value.
 	*/

package/bin/whet/cache/BaseCache.js

@@ -179,17 +179,7 @@ class BaseCache extends Register.inherits() {
 						_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 {
+				let regenerate = function () {
 					return ((stone.project.profiler != null) ? stone.project.profiler.withSpan(stone, "GeneratePartial", function () {
 						return stone.generatePartialSource(sourceId, hash);
 					}, {"sourceId": sourceId}) : stone.generatePartialSource(sourceId, hash)).then(function (result) {
@@ -208,7 +198,55 @@ class BaseCache extends Register.inherits() {
 						};
 					});
 				};
+				if (value != null && _gthis.hasSourceId(value, sourceId)) {
+					return _gthis.sourcePartial(stone, value, sourceId).then(function (src) {
+						if (src != null) {
+							return src;
+						};
+						return regenerate();
+					});
+				} else if (value != null && value.complete) {
+					return Promise.resolve(null);
+				} else {
+					return regenerate();
+				};
+			});
+		});
+	}
+	
+	/**
+	* Enumerate a stone's output ids from cache metadata alone — no file reads, no generation.
+	* Used by `Stone.listIds()` as a fast path before falling back to a full `getSource()`.
+	*
+	* Returns null (caller falls back) unless there is a *complete* entry whose hash matches the
+	* stone's current `finalMaybeHash()`. Sound because the output id-set is a pure function of that
+	* hash, so a complete matching entry's files are the authoritative id list. Stale/missing files
+	* on disk are irrelevant here — they're stat-validated (and regenerated) when actually fetched.
+	*
+	* Intentionally takes no lock and does not touch use-order/durability: listing is a read-only
+	* "what does this produce" query, not a use of the cached bytes.
+	*/
+	tryListIds(stone) {
+		let _gthis = this;
+		return stone.finalMaybeHash().then(function (hash) {
+			if (hash == null) {
+				return null;
+			};
+			let values = _gthis.cache.get(_gthis.key(stone));
+			if (values == null) {
+				return null;
+			};
+			let value = Lambda.find(values, function (v) {
+				if (SourceHash.equals(v.hash, hash)) {
+					return v.complete;
+				} else {
+					return false;
+				};
 			});
+			if (value == null) {
+				return null;
+			};
+			return _gthis.getValueIds(value);
 		});
 	}
 	set(source) {

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

@@ -20,6 +20,13 @@ export declare class CacheManager {
 	getSource(stone: AnyStone): Promise<Source>
 	getPartialSource(stone: AnyStone, sourceId: string): Promise<null | Source>
 	
+	/**
+	* Fast path for `Stone.listIds()`: enumerate output ids from cache metadata, without reading
+	* files or generating. Returns null when no usable entry exists (caller falls back to
+	* `getSource()`). `None` is never cached, so there's nothing to answer from.
+	*/
+	tryListIds(stone: AnyStone): Promise<null | string[]>
+	
 	/**
 	* Re-generates source even if the currently cached value is valid.
 	*/

package/bin/whet/cache/CacheManager.js

@@ -128,6 +128,29 @@ class CacheManager extends Register.inherits() {
 		};
 	}
 	
+	/**
+	* Fast path for `Stone.listIds()`: enumerate output ids from cache metadata, without reading
+	* files or generating. Returns null when no usable entry exists (caller falls back to
+	* `getSource()`). `None` is never cached, so there's nothing to answer from.
+	*/
+	tryListIds(stone) {
+		switch (stone.cacheStrategy._hx_index) {
+			case 0:
+				return Promise.resolve(null);
+				break
+			case 1:
+				return this.memCache.tryListIds(stone);
+				break
+			case 2:
+				return this.fileCache.tryListIds(stone);
+				break
+			case 3:
+				return this.fileCache.tryListIds(stone);
+				break
+			
+		};
+	}
+	
 	/**
 	* Re-generates source even if the currently cached value is valid.
 	*/

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

@@ -1,7 +1,7 @@
 import {BaseCache} from "./BaseCache"
 import {AnyStone} from "../Stone"
 import {SourceHash} from "../SourceHash"
-import {Source} from "../Source"
+import {Source, SourceData} from "../Source"
 
 export declare class FileCache extends BaseCache<string, RuntimeFileCacheValue> {
 	constructor(rootDir: string)
@@ -11,7 +11,15 @@ export declare class FileCache extends BaseCache<string, RuntimeFileCacheValue>
 	protected flushPromise: Promise<void>
 	protected key(stone: AnyStone): string
 	protected value(source: Source): Promise<RuntimeFileCacheValue>
+	
+	/**
+	* Read & validate a single cached file. Resolves with its `SourceData` when valid, or `null`
+	* when the file is missing or fails mtime+hash validation (a cache miss for that file). Rejects
+	* only on unexpected IO errors.
+	*/
+	protected readCachedFile(stone: AnyStone, file: RuntimeFileEntry): Promise<null | SourceData>
 	protected source(stone: AnyStone, value: RuntimeFileCacheValue): Promise<Source>
+	protected sourcePartial(stone: AnyStone, value: RuntimeFileCacheValue, sourceId: string): Promise<null | Source>
 	protected set(source: Source): Promise<RuntimeFileCacheValue>
 	protected getExistingDirs(stone: AnyStone): string[]
 	protected remove(stone: AnyStone, value: RuntimeFileCacheValue): Promise<any>
@@ -19,6 +27,7 @@ export declare class FileCache extends BaseCache<string, RuntimeFileCacheValue>
 	protected setRecentUseOrder(values: RuntimeFileCacheValue[], value: RuntimeFileCacheValue): boolean
 	protected getDirFor(value: RuntimeFileCacheValue): string
 	protected hasSourceId(value: RuntimeFileCacheValue, sourceId: string): boolean
+	protected getValueIds(value: RuntimeFileCacheValue): string[]
 	protected mergePartial(stone: AnyStone, existing: RuntimeFileCacheValue, addition: Source, markComplete: boolean): Promise<RuntimeFileCacheValue>
 	protected replaceEntry(stone: AnyStone, existing: RuntimeFileCacheValue, replacement: Source): Promise<RuntimeFileCacheValue>
 	protected flush(): Promise<void>
@@ -44,3 +53,11 @@ export type FileCacheValue<H, S> = {
 export type DbJson = {[key: string]: FileCacheValue<string, string>[]}
 
 export type RuntimeFileCacheValue = FileCacheValue<SourceHash, string>
+
+export type RuntimeFileEntry = {
+	fileHash: SourceHash, 
+	filePath: string, 
+	id: string, 
+	mtime?: null | number, 
+	size?: null | number
+}

package/bin/whet/cache/FileCache.js

@@ -84,67 +84,102 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 			return {"hash": source.hash, "ctime": source.ctime, "baseDir": source.getDirPath(), "complete": source.complete, "ctimePretty": null, "files": files};
 		});
 	}
+	
+	/**
+	* Read & validate a single cached file. Resolves with its `SourceData` when valid, or `null`
+	* when the file is missing or fails mtime+hash validation (a cache miss for that file). Rejects
+	* only on unexpected IO errors.
+	*/
+	readCachedFile(stone, file) {
+		let _gthis = this;
+		return new Promise(function (res, rej) {
+			let path = Path.posix.join(".", _gthis.rootDir, ".", file.filePath);
+			Fs.stat(path, function (statErr, stats) {
+				if (statErr != null) {
+					if (((statErr) instanceof Error) && statErr.code == "ENOENT") {
+						res(null);
+					} else {
+						rej(statErr);
+					};
+					return;
+				};
+				let mtimeMatch = file.mtime != null && stats.mtimeMs == file.mtime && (stats.size | 0) == file.size;
+				if (mtimeMatch && !stone.ignoreFileHash) {
+					SourceData.fromFileSkipHash(file.id, path, file.filePath, file.fileHash).then(res, rej);
+				} else {
+					SourceData.fromFile(file.id, path, file.filePath).then(function (sourceData) {
+						if (sourceData == null || !stone.ignoreFileHash && !SourceHash.equals(sourceData.hash, file.fileHash)) {
+							res(null);
+						} else {
+							res(sourceData);
+						};
+					}, function (err) {
+						if (((err) instanceof Error) && err.code == "ENOENT") {
+							res(null);
+						} else {
+							rej(err);
+						};
+					});
+				};
+			});
+		});
+	}
 	source(stone, value) {
+		let tmp;
 		let _g = stone.cacheStrategy;
 		if (_g._hx_index == 3) {
 			let _g1 = _g.path;
-			let invalidPath;
 			if (value.files.length == 1 && !(_g1.length == 0 || _g1.charCodeAt(_g1.length - 1) == 47)) {
-				invalidPath = value.files[0].filePath != _g1;
+				tmp = value.files[0].filePath != _g1;
 			} else {
 				let dir = _g1.substring(0, _g1.lastIndexOf("/") + 1);
-				invalidPath = value.baseDir != ((dir.length == 0) ? "./" : dir);
-			};
-			if (invalidPath) {
-				return Promise.resolve(null);
+				tmp = value.baseDir != ((dir.length == 0) ? "./" : dir);
 			};
+		} else {
+			tmp = false;
+		};
+		if (tmp) {
+			return Promise.resolve(null);
 		};
-		let _gthis = this;
 		let _g1 = [];
 		let _g2 = 0;
 		let _g3 = value.files;
-		while (_g2 < _g3.length) {
-			let file = _g3[_g2];
-			++_g2;
-			_g1.push(new Promise(function (res, rej) {
-				let path = Path.posix.join(".", _gthis.rootDir, ".", file.filePath);
-				Fs.stat(path, function (statErr, stats) {
-					if (statErr != null) {
-						if (((statErr) instanceof Error) && statErr.code == "ENOENT") {
-							rej("Invalid.");
-						} else {
-							rej(statErr);
-						};
-						return;
-					};
-					let mtimeMatch = file.mtime != null && stats.mtimeMs == file.mtime && (stats.size | 0) == file.size;
-					if (mtimeMatch && !stone.ignoreFileHash) {
-						SourceData.fromFileSkipHash(file.id, path, file.filePath, file.fileHash).then(res, rej);
-					} else {
-						SourceData.fromFile(file.id, path, file.filePath).then(function (sourceData) {
-							if (sourceData == null || !stone.ignoreFileHash && !SourceHash.equals(sourceData.hash, file.fileHash)) {
-								rej("Invalid.");
-							} else {
-								res(sourceData);
-							};
-						}, function (err) {
-							if (((err) instanceof Error) && err.code == "ENOENT") {
-								rej("Invalid.");
-							} else {
-								rej(err);
-							};
-						});
-					};
-				});
-			}));
-		};
+		while (_g2 < _g3.length) _g1.push(this.readCachedFile(stone, _g3[_g2++]));
 		return Promise.all(_g1).then(function (data) {
-			return new Source(data, value.hash, stone, value.ctime, (value.complete != null) ? value.complete : true);
-		}, function (rejected) {
-			if (rejected == "Invalid.") {
+			let _g = 0;
+			while (_g < data.length) if (data[_g++] == null) {
 				return null;
+			};
+			return new Source(data, value.hash, stone, value.ctime, (value.complete != null) ? value.complete : true);
+		});
+	}
+	sourcePartial(stone, value, sourceId) {
+		let tmp;
+		let _g = stone.cacheStrategy;
+		if (_g._hx_index == 3) {
+			let _g1 = _g.path;
+			if (value.files.length == 1 && !(_g1.length == 0 || _g1.charCodeAt(_g1.length - 1) == 47)) {
+				tmp = value.files[0].filePath != _g1;
+			} else {
+				let dir = _g1.substring(0, _g1.lastIndexOf("/") + 1);
+				tmp = value.baseDir != ((dir.length == 0) ? "./" : dir);
+			};
+		} else {
+			tmp = false;
+		};
+		if (tmp) {
+			return Promise.resolve(null);
+		};
+		let file = Lambda.find(value.files, function (f) {
+			return f.id == sourceId;
+		});
+		if (file == null) {
+			return Promise.resolve(null);
+		};
+		return this.readCachedFile(stone, file).then(function (sd) {
+			if (sd != null) {
+				return new Source([sd], value.hash, stone, value.ctime, false);
 			} else {
-				throw rejected;
 				return null;
 			};
 		});
@@ -239,6 +274,13 @@ class FileCache extends Register.inherits(() => BaseCache, true) {
 			return f.id == sourceId;
 		});
 	}
+	getValueIds(value) {
+		let _g = [];
+		let _g1 = 0;
+		let _g2 = value.files;
+		while (_g1 < _g2.length) _g.push(_g2[_g1++].id);
+		return _g;
+	}
 	mergePartial(stone, existing, addition, markComplete) {
 		let _g = [];
 		let _g1 = 0;

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

@@ -7,9 +7,11 @@ export declare class MemoryCache extends BaseCache<AnyStone, Source> {
 	protected key(stone: AnyStone): AnyStone
 	protected value(source: Source): Promise<Source>
 	protected source(stone: AnyStone, value: Source): Promise<Source>
+	protected sourcePartial(stone: AnyStone, value: Source, sourceId: string): Promise<null | Source>
 	protected getExistingDirs(stone: AnyStone): string[]
 	protected getDirFor(value: Source): string
 	protected hasSourceId(value: Source, sourceId: string): boolean
+	protected getValueIds(value: Source): string[]
 	protected mergePartial(stone: AnyStone, existing: Source, addition: Source, markComplete: boolean): Promise<Source>
 	protected replaceEntry(stone: AnyStone, existing: Source, replacement: Source): Promise<Source>
 }

package/bin/whet/cache/MemoryCache.js

@@ -20,6 +20,9 @@ class MemoryCache extends Register.inherits(() => BaseCache, true) {
 	source(stone, value) {
 		return Promise.resolve(value);
 	}
+	sourcePartial(stone, value, sourceId) {
+		return Promise.resolve(value.filterTo(sourceId));
+	}
 	getExistingDirs(stone) {
 		let list = this.cache.inst.get(stone);
 		if (list != null) {
@@ -52,6 +55,13 @@ class MemoryCache extends Register.inherits(() => BaseCache, true) {
 			return d.id == sourceId;
 		});
 	}
+	getValueIds(value) {
+		let _g = [];
+		let _g1 = 0;
+		let _g2 = value.data;
+		while (_g1 < _g2.length) _g.push(_g2[_g1++].id);
+		return _g;
+	}
 	mergePartial(stone, existing, addition, markComplete) {
 		let mergedData = existing.data.slice();
 		if (addition != null) {

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

@@ -13,6 +13,7 @@ export declare class Files extends Stone<FilesConfig> {
 	protected generateHash(): Promise<SourceHash>
 	protected list(): Promise<null | string[]>
 	protected generate(hash: SourceHash): Promise<SourceData[]>
+	protected generatePartial(sourceId: string, hash: SourceHash): Promise<null | SourceData[]>
 	protected walk<T>(onFile: ((arg0: string) => T), onDirFile: ((arg0: string, arg1: string) => T)): Promise<T[]>
 	protected fromCwd(file: string, dir: string): {
 		id: string, 

package/bin/whet/stones/Files.js

@@ -7,6 +7,7 @@ import {SourceHash} from "../SourceHash.js"
 import {SourceData} from "../Source.js"
 import {Project} from "../Project.js"
 import {Register} from "../../genes/Register.js"
+import {Lambda} from "../../Lambda.js"
 
 const $global = Register.$global
 
@@ -128,6 +129,55 @@ class Files extends Register.inherits(() => Stone, true) {
 			return Promise.all(fileProms);
 		});
 	}
+	generatePartial(sourceId, hash) {
+		let _gthis = this;
+		let onDirFile = function (dir, dirFile) {
+			let p_id;
+			let pathId = IdUtils.fromCwdPath(dirFile, RootDir.fromProject(_gthis.project));
+			if (dir == "/") {
+				p_id = pathId;
+			} else {
+				if (!(dir.length == 0 || dir.charCodeAt(dir.length - 1) == 47)) {
+					throw new Error("\"" + dir + "\" is not a directory.");
+				};
+				let p_id1;
+				let dir1 = pathId.substring(0, pathId.lastIndexOf("/") + 1);
+				p_id1 = ((dir1.length == 0) ? "./" : dir1).indexOf(dir) == 0;
+				p_id = (p_id1) ? pathId.substring(dir.length) : null;
+			};
+			return {"id": p_id, "cwd": dirFile, "pathId": pathId};
+		};
+		let files = [];
+		let dirs = [];
+		let _g = 0;
+		let _g1 = MaybeArray_Fields_.makeArray(this.config.paths);
+		while (_g < _g1.length) {
+			let path = _g1[_g];
+			++_g;
+			if (path.length == 0 || path.charCodeAt(path.length - 1) == 47) {
+				dirs.push(Utils.listDirectoryFiles(this.cwdPath(path), this.config.recursive).then(function (arr) {
+					let _g = 0;
+					while (_g < arr.length) files.push(onDirFile(path, arr[_g++]));
+				}));
+			} else {
+				let id = path;
+				files.push({"id": id.substring(id.lastIndexOf("/") + 1), "cwd": _gthis.cwdPath(path), "pathId": path});
+			};
+		};
+		return Promise.all(dirs).then(function (_) {
+			return files;
+		}).then(function (entries) {
+			let match = Lambda.find(entries, function (e) {
+				return e.id == sourceId;
+			});
+			if (match == null) {
+				return Promise.resolve(null);
+			};
+			return SourceData.fromFile(match.id, match.cwd, match.pathId).then(function (sd) {
+				return [sd];
+			});
+		});
+	}
 	walk(onFile, onDirFile) {
 		let files = [];
 		let dirs = [];

package/package.json

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