whet 0.1.0 → 0.2.0

package/bin/whet/cache/CacheManager.js

@@ -1,7 +1,9 @@
 import {MemoryCache} from "./MemoryCache.js"
 import {FileCache} from "./FileCache.js"
 import {CacheStrategy, CacheDurability, DurabilityCheck} from "./Cache.js"
+import {BaseCache} from "./BaseCache.js"
 import {RootDir} from "../SourceId.js"
+import {SourceHash} from "../SourceHash.js"
 import {Log} from "../Log.js"
 import * as Path from "path"
 import {Register} from "../../genes/Register.js"
@@ -26,8 +28,36 @@ class CacheManager extends Register.inherits() {
 		switch (_g._hx_index) {
 			case 0:
 				return stone.acquire(function () {
-					return stone.finalMaybeHash().then(function (hash) {
-						return stone.generateSource(hash);
+					return ((stone.project.profiler != null) ? stone.project.profiler.withSpan(stone, "Hash", function () {
+						return stone.finalMaybeHash().then(function (hash) {
+							let span = (stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null;
+							let meta = (hash != null) ? SourceHash.toHex(hash) : null;
+							if (span != null) {
+								span.metadata = {"hashHex": meta};
+							};
+							return hash;
+						});
+					}, null) : stone.finalMaybeHash().then(function (hash) {
+						let span = (stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null;
+						let meta = (hash != null) ? SourceHash.toHex(hash) : null;
+						if (span != null) {
+							span.metadata = {"hashHex": meta};
+						};
+						return hash;
+					})).then(function (hash) {
+						if (stone.project.profiler != null) {
+							return stone.project.profiler.withSpan(stone, "Generate", function () {
+								return stone.generateSource(hash).then(function (src) {
+									BaseCache.setGenerateMeta((stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null, src);
+									return src;
+								});
+							}, null);
+						} else {
+							return stone.generateSource(hash).then(function (src) {
+								BaseCache.setGenerateMeta((stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null, src);
+								return src;
+							});
+						};
 					});
 				});
 				break
@@ -51,10 +81,34 @@ class CacheManager extends Register.inherits() {
 		switch (_g._hx_index) {
 			case 0:
 				return stone.acquire(function () {
-					return stone.finalMaybeHash().then(function (hash) {
-						return stone.generatePartialSource(sourceId, hash).then(function (r) {
-							return r.source.filterTo(sourceId);
+					return ((stone.project.profiler != null) ? stone.project.profiler.withSpan(stone, "Hash", function () {
+						return stone.finalMaybeHash().then(function (hash) {
+							let span = (stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null;
+							let meta = (hash != null) ? SourceHash.toHex(hash) : null;
+							if (span != null) {
+								span.metadata = {"hashHex": meta};
+							};
+							return hash;
 						});
+					}, null) : stone.finalMaybeHash().then(function (hash) {
+						let span = (stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null;
+						let meta = (hash != null) ? SourceHash.toHex(hash) : null;
+						if (span != null) {
+							span.metadata = {"hashHex": meta};
+						};
+						return hash;
+					})).then(function (hash) {
+						if (stone.project.profiler != null) {
+							return stone.project.profiler.withSpan(stone, "GeneratePartial", function () {
+								return stone.generatePartialSource(sourceId, hash).then(function (r) {
+									return r.source.filterTo(sourceId);
+								});
+							}, {"sourceId": sourceId});
+						} else {
+							return stone.generatePartialSource(sourceId, hash).then(function (r) {
+								return r.source.filterTo(sourceId);
+							});
+						};
 					});
 				});
 				break
@@ -82,8 +136,36 @@ class CacheManager extends Register.inherits() {
 		switch (stone.cacheStrategy._hx_index) {
 			case 0:
 				return stone.acquire(function () {
-					return stone.finalMaybeHash().then(function (hash) {
-						return stone.generateSource(hash);
+					return ((stone.project.profiler != null) ? stone.project.profiler.withSpan(stone, "Hash", function () {
+						return stone.finalMaybeHash().then(function (hash) {
+							let span = (stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null;
+							let meta = (hash != null) ? SourceHash.toHex(hash) : null;
+							if (span != null) {
+								span.metadata = {"hashHex": meta};
+							};
+							return hash;
+						});
+					}, null) : stone.finalMaybeHash().then(function (hash) {
+						let span = (stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null;
+						let meta = (hash != null) ? SourceHash.toHex(hash) : null;
+						if (span != null) {
+							span.metadata = {"hashHex": meta};
+						};
+						return hash;
+					})).then(function (hash) {
+						if (stone.project.profiler != null) {
+							return stone.project.profiler.withSpan(stone, "Generate", function () {
+								return stone.generateSource(hash).then(function (src) {
+									BaseCache.setGenerateMeta((stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null, src);
+									return src;
+								});
+							}, null);
+						} else {
+							return stone.generateSource(hash).then(function (src) {
+								BaseCache.setGenerateMeta((stone.project.profiler != null) ? stone.project.profiler.getCurrentSpan() : null, src);
+								return src;
+							});
+						};
 					});
 				});
 				break

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

@@ -0,0 +1,65 @@
+import {SpanStats} from "./SpanStats"
+import {SpanRecorder} from "./SpanRecorder"
+import {SpanEvent, AnySpan, SpanEventType} from "./Span"
+import {AnyStone} from "../Stone"
+import {AsyncLocalStorage} from "node:async_hooks"
+
+export declare class Profiler {
+	constructor(config?: null | ProfilerConfig)
+	recorder: SpanRecorder
+	stats: SpanStats
+	protected listeners: ((arg0: SpanEvent) => void)[]
+	protected context: AsyncLocalStorage<AnySpan>
+	protected baseEpochUs: number
+	protected basePerfUs: number
+	protected nextSpanId: number
+	
+	/**
+	Primary API: wraps an async operation with timing and ALS context.
+	*/
+	withSpan<T, R>(stone: AnyStone, op: string, fn: (() => Promise<R>), meta?: null | T): Promise<R>
+	
+	/**
+	Secondary API: manual start for spans where no function can be wrapped (e.g. LockWait).
+	*/
+	startSpan<T>(stone: AnyStone, op: string, meta?: null | T): AnySpan
+	
+	/**
+	Complete a manually started span.
+	*/
+	endSpan(span: AnySpan): void
+	
+	/**
+	Returns the current span from AsyncLocalStorage context, or null if none.
+	*/
+	getCurrentSpan(): null | AnySpan
+	
+	/**
+	Subscribe to span events. Returns unsubscribe function.
+	*/
+	subscribe(listener: ((arg0: SpanEvent) => void)): (() => void)
+	
+	/**
+	Export spans in the given format ("json" or "trace"). Defaults to "json".
+	*/
+	export(format: string): any
+	
+	/**
+	Return spans recorded since the given span ID (exclusive).
+	*/
+	getSpansSince(sinceId: number): AnySpan[]
+	
+	/**
+	Return aggregated profiling summary.
+	*/
+	getSummary(): any
+	protected exportJson(): any
+	protected exportChromeTrace(): any
+	protected serializeSpan(span: AnySpan): any
+	protected emit(type: SpanEventType, span: AnySpan): void
+	protected static ensureStoneEntry(byStone: {[key: string]: any}, stone: string): void
+}
+
+export type ProfilerConfig = {
+	maxSpans?: null | number
+}

package/bin/whet/profiler/Profiler.js

@@ -0,0 +1,351 @@
+import {SpanStats} from "./SpanStats.js"
+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 {EsMap} from "../../genes/util/EsMap.js"
+import {Register} from "../../genes/Register.js"
+import {Std} from "../../Std.js"
+import {Reflect as Reflect__1} from "../../Reflect.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+export const Profiler = Register.global("$hxClasses")["whet.profiler.Profiler"] = 
+class Profiler extends Register.inherits() {
+	[Register.new](config) {
+		this.nextSpanId = 0;
+		this.listeners = [];
+		this.recorder = new SpanRecorder((config != null && config.maxSpans != null) ? config.maxSpans : 10000);
+		this.stats = new SpanStats();
+		this.context = new AsyncLocalStorage();
+		this.baseEpochUs = Date.now() * 1000;
+		this.basePerfUs = performance.now() * 1000;
+	}
+	
+	/**
+	Primary API: wraps an async operation with timing and ALS context.
+	*/
+	withSpan(stone, op, fn, meta) {
+		let parent = this.context.getStore();
+		let span = new Span(this.nextSpanId++, (parent != null) ? parent.id : null, stone.id, op, performance.now(), meta);
+		span.estimatedDuration = this.stats.getEstimate(stone.id, op);
+		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);
+			});
+		});
+	}
+	
+	/**
+	Secondary API: manual start for spans where no function can be wrapped (e.g. LockWait).
+	*/
+	startSpan(stone, op, meta) {
+		let parent = this.context.getStore();
+		let span = new Span(this.nextSpanId++, (parent != null) ? parent.id : null, stone.id, op, performance.now(), meta);
+		span.estimatedDuration = this.stats.getEstimate(stone.id, op);
+		this.emit(SpanEventType.Start, span);
+		return span;
+	}
+	
+	/**
+	Complete a manually started span.
+	*/
+	endSpan(span) {
+		span.endTime = performance.now();
+		span.duration = span.endTime - span.startTime;
+		span.status = SpanStatus.Ok;
+		this.recorder.record(span);
+		this.stats.update(span.stone, span.operation, span.duration);
+		this.emit(SpanEventType.End, span);
+	}
+	
+	/**
+	Returns the current span from AsyncLocalStorage context, or null if none.
+	*/
+	getCurrentSpan() {
+		return this.context.getStore();
+	}
+	
+	/**
+	Subscribe to span events. Returns unsubscribe function.
+	*/
+	subscribe(listener) {
+		this.listeners.push(listener);
+		let _gthis = this;
+		return function () {
+			HxOverrides.remove(_gthis.listeners, listener);
+		};
+	}
+	
+	/**
+	Export spans in the given format ("json" or "trace"). Defaults to "json".
+	*/
+	export(format) {
+		if (format == "trace") {
+			return this.exportChromeTrace();
+		} else {
+			return this.exportJson();
+		};
+	}
+	
+	/**
+	Return spans recorded since the given span ID (exclusive).
+	*/
+	getSpansSince(sinceId) {
+		return this.recorder.getSpansSince(sinceId);
+	}
+	
+	/**
+	Return aggregated profiling summary.
+	*/
+	getSummary() {
+		let spans = this.recorder.getSpans();
+		let byStone = {};
+		let byOperation = {};
+		let cacheHits = 0;
+		let cacheLookups = 0;
+		let _g = 0;
+		while (_g < spans.length) {
+			let span = spans[_g];
+			++_g;
+			let opKey = span.operation;
+			let opEntry = byOperation[opKey];
+			if (opEntry == null) {
+				opEntry = {"count": 0, "totalMs": 0.0};
+				byOperation[opKey] = opEntry;
+			};
+			opEntry.count++;
+			opEntry.totalMs += span.duration;
+			if (opKey == "Generate") {
+				Profiler.ensureStoneEntry(byStone, span.stone);
+				let entry = byStone[span.stone];
+				entry.generates++;
+				entry.totalDuration += span.duration;
+				entry.avgDuration = entry.totalDuration / entry.generates;
+				entry.lastDuration = span.duration;
+			};
+			if (span.metadata != null) {
+				let meta = span.metadata;
+				if (meta.cacheResult != null) {
+					++cacheLookups;
+					if (meta.cacheResult == "hit") {
+						++cacheHits;
+						Profiler.ensureStoneEntry(byStone, span.stone);
+						byStone[span.stone].cacheHits++;
+					};
+				};
+			};
+		};
+		return {"byStone": byStone, "byOperation": byOperation, "cacheHitRate": (cacheLookups > 0) ? cacheHits / cacheLookups : 0.0};
+	}
+	exportJson() {
+		let spans = this.recorder.getSpans();
+		let _g = [];
+		let _g1 = 0;
+		while (_g1 < spans.length) _g.push(this.serializeSpan(spans[_g1++]));
+		let stoneSet_inst = new Map();
+		let generateCount = 0;
+		let cacheHits = 0;
+		let cacheLookups = 0;
+		let _g2 = 0;
+		while (_g2 < spans.length) {
+			let span = spans[_g2];
+			++_g2;
+			stoneSet_inst.set(span.stone, true);
+			if (span.operation == "Generate") {
+				++generateCount;
+			};
+			if (span.metadata != null) {
+				let meta = span.metadata;
+				if (meta.cacheResult != null) {
+					++cacheLookups;
+					if (meta.cacheResult == "hit") {
+						++cacheHits;
+					};
+				};
+			};
+		};
+		let stoneCount = 0;
+		let _ = EsMap.adaptIterator(stoneSet_inst.values());
+		while (_.hasNext()) {
+			_.next();
+			++stoneCount;
+		};
+		return {"spans": _g, "meta": {"spanCount": spans.length, "stoneCount": stoneCount, "totalGenerations": generateCount, "cacheHitRate": (cacheLookups > 0) ? cacheHits / cacheLookups : 0.0}};
+	}
+	exportChromeTrace() {
+		let spans = this.recorder.getSpans();
+		let spanById_inst = new Map();
+		let _g = 0;
+		while (_g < spans.length) {
+			let span = spans[_g];
+			++_g;
+			spanById_inst.set(span.id, span);
+		};
+		let childrenOf_inst = new Map();
+		let roots = [];
+		let _g1 = 0;
+		while (_g1 < spans.length) {
+			let span = spans[_g1];
+			++_g1;
+			let pid = span.parentId;
+			if (pid == null || !spanById_inst.has(pid)) {
+				roots.push(span);
+			} else {
+				if (!childrenOf_inst.has(pid)) {
+					childrenOf_inst.set(pid, []);
+				};
+				childrenOf_inst.get(pid).push(span);
+			};
+		};
+		let spanTid_inst = new Map();
+		let nextTid = 1;
+		let assignTids = null;
+		assignTids = function (span, tid) {
+			spanTid_inst.set(span.id, tid);
+			let children = childrenOf_inst.get(span.id);
+			if (children == null || children.length == 0) {
+				return;
+			};
+			children.sort(function (a, b) {
+				return Reflect__1.compare(a.startTime, b.startTime);
+			});
+			let laneEndTimes = [];
+			let laneTids = [];
+			let _g = 0;
+			while (_g < children.length) {
+				let child = children[_g];
+				++_g;
+				let lane = -1;
+				let _g1 = 0;
+				let _g2 = laneEndTimes.length;
+				while (_g1 < _g2) {
+					let i = _g1++;
+					if (laneEndTimes[i] <= child.startTime) {
+						lane = i;
+						break;
+					};
+				};
+				if (lane == -1) {
+					lane = laneEndTimes.length;
+					let assignTids;
+					if (lane == 0) {
+						assignTids = tid;
+					} else {
+						nextTid += 1;
+						assignTids = nextTid - 1;
+					};
+					laneTids.push(assignTids);
+					laneEndTimes.push(child.endTime);
+				} else {
+					laneEndTimes[lane] = child.endTime;
+				};
+				assignTids(child, laneTids[lane]);
+			};
+		};
+		roots.sort(function (a, b) {
+			return Reflect__1.compare(a.startTime, b.startTime);
+		});
+		let _g2 = 0;
+		while (_g2 < roots.length) {
+			nextTid += 1;
+			assignTids(roots[_g2++], nextTid - 1);
+		};
+		let events = [];
+		let tidNames = new IntMap();
+		let _g3 = 0;
+		while (_g3 < spans.length) {
+			let span = spans[_g3];
+			++_g3;
+			let tid = spanTid_inst.get(span.id);
+			if (tid != null && !tidNames.inst.has(tid)) {
+				tidNames.inst.set(tid, span.stone);
+			};
+		};
+		let map = tidNames;
+		let _g_keys = map.keys();
+		while (_g_keys.hasNext()) {
+			let key = _g_keys.next();
+			events.push({"ph": "M", "pid": 1, "tid": key, "name": "thread_name", "args": {"name": map.get(key)}});
+		};
+		let flowId = 0;
+		let _g4 = 0;
+		while (_g4 < spans.length) {
+			let span = spans[_g4];
+			++_g4;
+			let tid = spanTid_inst.get(span.id);
+			if (tid == null) {
+				continue;
+			};
+			let ts = this.baseEpochUs + (span.startTime * 1000 - this.basePerfUs);
+			events.push({"ph": "X", "name": span.operation + " " + span.stone, "cat": "whet", "ts": ts, "dur": span.duration * 1000, "pid": 1, "tid": tid, "args": (span.metadata != null) ? span.metadata : {}});
+			if (span.parentId != null) {
+				let parent = spanById_inst.get(span.parentId);
+				if (parent != null) {
+					let parentTid = spanTid_inst.get(parent.id);
+					if (parentTid != null && parentTid != tid) {
+						events.push({"ph": "s", "id": flowId, "pid": 1, "tid": parentTid, "ts": this.baseEpochUs + (parent.startTime * 1000 - this.basePerfUs), "name": "trigger", "cat": "flow"});
+						events.push({"ph": "f", "bp": "e", "id": flowId, "pid": 1, "tid": tid, "ts": ts, "name": "trigger", "cat": "flow"});
+						++flowId;
+					};
+				};
+			};
+		};
+		return {"traceEvents": events};
+	}
+	serializeSpan(span) {
+		let _g = span.status;
+		let tmp;
+		switch (_g._hx_index) {
+			case 0:
+				tmp = "ok";
+				break
+			case 1:
+				tmp = "error: " + _g.msg;
+				break
+			
+		};
+		return {"id": span.id, "parentId": span.parentId, "stone": span.stone, "operation": span.operation, "startTime": span.startTime, "endTime": span.endTime, "duration": span.duration, "estimatedDuration": span.estimatedDuration, "metadata": span.metadata, "status": tmp};
+	}
+	emit(type, span) {
+		let event = {"type": type, "span": span};
+		let _g = 0;
+		let _g1 = this.listeners;
+		while (_g < _g1.length) _g1[_g++](event);
+	}
+	static ensureStoneEntry(byStone, stone) {
+		if (!Object.prototype.hasOwnProperty.call(byStone, stone)) {
+			byStone[stone] = {"generates": 0, "totalDuration": 0.0, "avgDuration": 0.0, "lastDuration": 0.0, "cacheHits": 0};
+		};
+	}
+	static get __name__() {
+		return "whet.profiler.Profiler"
+	}
+	get __class__() {
+		return Profiler
+	}
+}
+Profiler.prototype.recorder = null;
+Profiler.prototype.stats = null;
+Profiler.prototype.listeners = null;
+Profiler.prototype.context = null;
+Profiler.prototype.baseEpochUs = null;
+Profiler.prototype.basePerfUs = null;
+Profiler.prototype.nextSpanId = null;
+

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

@@ -0,0 +1,90 @@
+
+export declare class Span<T> {
+	constructor(id: number, parentId: null | number, stone: string, op: string, startTime: number, metadata?: null | T)
+	id: number
+	parentId: null | number
+	stone: string
+	operation: string
+	startTime: number
+	endTime: number
+	duration: number
+	estimatedDuration: number
+	metadata: T
+	status: SpanStatus
+}
+
+export type AnySpan = Span<any>
+
+export declare namespace SpanStatus {
+	export type Ok = {_hx_index: 0, __enum__: "whet.profiler.SpanStatus"}
+	export const Ok: Ok
+	export type Error = {_hx_index: 1, msg: string, __enum__: "whet.profiler.SpanStatus"}
+	export const Error: (msg: string) => SpanStatus
+}
+
+export declare type SpanStatus = 
+	| SpanStatus.Ok
+	| SpanStatus.Error
+
+export declare namespace SpanEventType {
+	export type Start = {_hx_index: 0, __enum__: "whet.profiler.SpanEventType"}
+	export const Start: Start
+	export type End = {_hx_index: 1, __enum__: "whet.profiler.SpanEventType"}
+	export const End: End
+}
+
+export declare type SpanEventType = 
+	| SpanEventType.Start
+	| SpanEventType.End
+
+export type SpanEvent = {
+	span: AnySpan, 
+	type: SpanEventType
+}
+
+/**
+Metadata types per span operation.
+*/
+export type LockWaitMeta = {
+	queueLength?: null | number, 
+	queuePosition?: null | number
+}
+
+export type LockHeldMeta = {
+	cacheResult?: null | string
+}
+
+export type HashMeta = {
+	dependencyCount?: null | number, 
+	hashHex?: null | string
+}
+
+export type GenerateMeta = {
+	outputCount?: null | number, 
+	totalBytes?: null | number
+}
+
+export type GeneratePartialMeta = {
+	outputBytes?: null | number, 
+	sourceId?: null | string
+}
+
+export type DepResolveMeta = {
+	dependencyIds?: null | string[]
+}
+
+export type CacheWriteMeta = {
+	entryCount?: null | number, 
+	strategy?: null | string
+}
+
+export type ListMeta = {
+	resultCount?: null | number
+}
+
+export type ServeMeta = {
+	method?: null | string, 
+	path?: null | string, 
+	responseBytes?: null | number, 
+	statusCode?: null | number
+}

package/bin/whet/profiler/Span.js

@@ -0,0 +1,56 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const Span = Register.global("$hxClasses")["whet.profiler.Span"] = 
+class Span extends Register.inherits() {
+	[Register.new](id, parentId, stone, op, startTime, metadata) {
+		this.id = id;
+		this.parentId = parentId;
+		this.stone = stone;
+		this.operation = op;
+		this.startTime = startTime;
+		this.metadata = metadata;
+		this.estimatedDuration = 0;
+		this.status = SpanStatus.Ok;
+	}
+	static get __name__() {
+		return "whet.profiler.Span"
+	}
+	get __class__() {
+		return Span
+	}
+}
+Span.prototype.id = null;
+Span.prototype.parentId = null;
+Span.prototype.stone = null;
+Span.prototype.operation = null;
+Span.prototype.startTime = null;
+Span.prototype.endTime = null;
+Span.prototype.duration = null;
+Span.prototype.estimatedDuration = null;
+Span.prototype.metadata = null;
+Span.prototype.status = null;
+
+
+export const SpanStatus = 
+Register.global("$hxEnums")["whet.profiler.SpanStatus"] = 
+{
+	__ename__: "whet.profiler.SpanStatus",
+	
+	Ok: {_hx_name: "Ok", _hx_index: 0, __enum__: "whet.profiler.SpanStatus"},
+	Error: Object.assign((msg) => ({_hx_index: 1, __enum__: "whet.profiler.SpanStatus", "msg": msg}), {_hx_name: "Error", __params__: ["msg"]})
+}
+SpanStatus.__constructs__ = [SpanStatus.Ok, SpanStatus.Error]
+SpanStatus.__empty_constructs__ = [SpanStatus.Ok]
+
+export const SpanEventType = 
+Register.global("$hxEnums")["whet.profiler.SpanEventType"] = 
+{
+	__ename__: "whet.profiler.SpanEventType",
+	
+	Start: {_hx_name: "Start", _hx_index: 0, __enum__: "whet.profiler.SpanEventType"},
+	End: {_hx_name: "End", _hx_index: 1, __enum__: "whet.profiler.SpanEventType"}
+}
+SpanEventType.__constructs__ = [SpanEventType.Start, SpanEventType.End]
+SpanEventType.__empty_constructs__ = [SpanEventType.Start, SpanEventType.End]

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

@@ -0,0 +1,20 @@
+import {AnySpan} from "./Span"
+
+export declare class SpanRecorder {
+	constructor(maxSize: number)
+	maxSize: number
+	totalCount: number
+	protected buffer: AnySpan[]
+	protected writeIndex: number
+	record(span: AnySpan): void
+	
+	/**
+	Returns all recorded spans in chronological order.
+	*/
+	getSpans(): AnySpan[]
+	
+	/**
+	Returns spans recorded since the given span ID (exclusive).
+	*/
+	getSpansSince(sinceId: number): AnySpan[]
+}