substrate-ai 0.20.55 → 0.20.57

package/dist/cli/index.js

@@ -1,31 +1,32 @@
 #!/usr/bin/env node
-import { FileStateStore, RunManifest, SUBSTRATE_OWNED_SETTINGS_KEYS, SupervisorLock, VALID_PHASES, WorkGraphRepository, ZERO_FINDINGS_BY_AUTHOR, ZERO_FINDING_COUNTS, ZERO_PROBE_AUTHOR_METRICS, aggregateProbeAuthorMetrics, buildPipelineStatusOutput, createDatabaseAdapter, createStateStore, findPackageRoot, formatOutput, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, inspectProcessTree, parseDbTimestampAsUtc, parseRuntimeProbes, registerHealthCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveRunManifest, rollupFindingCounts, rollupFindingsByAuthor, rollupProbeAuthorByClass, rollupProbeAuthorMetrics } from "../health-PSnpYDAa.js";
+import { FileStateStore, RunManifest, SUBSTRATE_OWNED_SETTINGS_KEYS, SupervisorLock, VALID_PHASES, WorkGraphRepository, ZERO_FINDINGS_BY_AUTHOR, ZERO_FINDING_COUNTS, ZERO_PROBE_AUTHOR_METRICS, aggregateProbeAuthorMetrics, buildPipelineStatusOutput, createDatabaseAdapter, createStateStore, findPackageRoot, formatOutput, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, inspectProcessTree, parseDbTimestampAsUtc, parseRuntimeProbes, registerHealthCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveRunManifest, rollupFindingCounts, rollupFindingsByAuthor, rollupProbeAuthorByClass, rollupProbeAuthorMetrics } from "../health-PdI4-96I.js";
 import { createLogger } from "../logger-KeHncl-f.js";
 import { createEventBus } from "../helpers-CElYrONe.js";
-import { AdapterRegistry, BudgetConfigSchema, CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, ConfigError, CostTrackerConfigSchema, DEFAULT_CONFIG, DoltClient, DoltNotInstalled, GlobalSettingsSchema, InMemoryDatabaseAdapter, IngestionServer, MonitorDatabaseImpl, OPERATIONAL_FINDING, PartialGlobalSettingsSchema, PartialProviderConfigSchema, ProvidersSchema, RoutingRecommender, STORY_METRICS, TelemetryConfigSchema, addTokenUsage, aggregateTokenUsageForRun, checkDoltInstalled, compareRunMetrics, createAmendmentRun, createConfigSystem, createDecision, createDoltClient, createPipelineRun, getActiveDecisions, getAllCostEntriesFiltered, getBaselineRunMetrics, getDecisionsByCategory, getDecisionsByPhaseForRun, getLatestCompletedRun, getLatestRun, getPipelineRunById, getPlanningCostTotal, getRetryableEscalations, getRunMetrics, getRunningPipelineRuns, getSessionCostSummary, getSessionCostSummaryFiltered, getStoryMetricsForRun, getTokenUsageSummary, incrementRunRestarts, initSchema, initializeDolt, listRunMetrics, loadParentRunDecisions, supersedeDecision, tagRunAsBaseline, updatePipelineRun } from "../dist-VcMmfo2w.js";
+import { AdapterRegistry, BudgetConfigSchema, CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, ConfigError, CostTrackerConfigSchema, DEFAULT_CONFIG, DoltClient, DoltNotInstalled, GlobalSettingsSchema, InMemoryDatabaseAdapter, IngestionServer, MonitorDatabaseImpl, OPERATIONAL_FINDING, PartialGlobalSettingsSchema, PartialProviderConfigSchema, ProvidersSchema, RoutingRecommender, STORY_METRICS, TelemetryConfigSchema, addTokenUsage, aggregateTokenUsageForRun, checkDoltInstalled, compareRunMetrics, createAmendmentRun, createConfigSystem, createDecision, createDoltClient, createPipelineRun, getActiveDecisions, getAllCostEntriesFiltered, getBaselineRunMetrics, getDecisionsByCategory, getDecisionsByPhaseForRun, getLatestCompletedRun, getLatestRun, getPipelineRunById, getPlanningCostTotal, getRetryableEscalations, getRunMetrics, getRunningPipelineRuns, getSessionCostSummary, getSessionCostSummaryFiltered, getStoryMetricsForRun, getTokenUsageSummary, incrementRunRestarts, initSchema, initializeDolt, listRunMetrics, loadParentRunDecisions, supersedeDecision, tagRunAsBaseline, updatePipelineRun } from "../dist-W2emvN3F.js";
 import "../adapter-registry-DXLMTmfD.js";
-import { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, EpicIngester, GitClient, GrammarLoader, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, formatPhaseCompletionSummary, getFactoryRunSummaries, getScenarioResultsForRun, getTwinRunsForRun, listGraphRuns, registerExportCommand, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runProbeAuthor, runSolutioningPhase, validateStopAfterFromConflict } from "../run-CeaNSnD6.js";
-import "../errors-CogpxBUg.js";
+import { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, EpicIngester, GLOBSTAR, GitClient, GrammarLoader, Minimatch, Minipass, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, escape, formatPhaseCompletionSummary, getFactoryRunSummaries, getScenarioResultsForRun, getTwinRunsForRun, listGraphRuns, registerExportCommand, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runProbeAuthor, runSolutioningPhase, unescape, validateStopAfterFromConflict } from "../run-DcDoaG12.js";
+import "../errors-CKFu8YI9.js";
 import "../routing-CcBOCuC9.js";
 import "../decisions-C0pz9Clx.js";
 import "../version-manager-impl-BmOWu8ml.js";
-import { registerUpgradeCommand } from "../upgrade-CF4__LCr.js";
+import { registerUpgradeCommand } from "../upgrade-CAqLkNUP.js";
 import { Command } from "commander";
 import { fileURLToPath } from "url";
 import { dirname, join, resolve } from "path";
 import { access, mkdir, readFile, writeFile } from "fs/promises";
 import yaml from "js-yaml";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import * as actualFS from "node:fs";
+import { existsSync, promises, readFileSync, writeFileSync } from "node:fs";
 import { execFile, spawn } from "node:child_process";
 import * as path$3 from "node:path";
 import * as path$2 from "node:path";
 import * as path$1 from "node:path";
-import { basename as basename$1, join as join$1, resolve as resolve$1 } from "node:path";
+import { basename as basename$1, join as join$1, posix, relative, resolve as resolve$1, win32 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import * as fs from "node:fs/promises";
-import { access as access$1, readFile as readFile$1, readdir as readdir$1 } from "node:fs/promises";
-import { appendFileSync, chmodSync, cpSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { access as access$1, lstat, readFile as readFile$1, readdir as readdir$1, readlink, realpath } from "node:fs/promises";
+import { appendFileSync, chmodSync, cpSync, existsSync as existsSync$1, lstatSync, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdir as readdir$2, readdirSync as readdirSync$1, readlinkSync, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "fs";
 import { homedir } from "os";
 import { createRequire } from "node:module";
 import { fileURLToPath as fileURLToPath$1 } from "node:url";
@@ -3037,10 +3038,3810 @@ function registerConfigCommand(program, _version) {
 	});
 }
 
+//#endregion
+//#region node_modules/lru-cache/dist/esm/index.js
+/**
+* @module LRUCache
+*/
+const perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const warned = new Set();
+/* c8 ignore start */
+const PROCESS = typeof process === "object" && !!process ? process : {};
+/* c8 ignore start */
+const emitWarning = (msg, type, code, fn) => {
+	typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+};
+let AC = globalThis.AbortController;
+let AS = globalThis.AbortSignal;
+/* c8 ignore start */
+if (typeof AC === "undefined") {
+	AS = class AbortSignal {
+		onabort;
+		_onabort = [];
+		reason;
+		aborted = false;
+		addEventListener(_, fn) {
+			this._onabort.push(fn);
+		}
+	};
+	AC = class AbortController {
+		constructor() {
+			warnACPolyfill();
+		}
+		signal = new AS();
+		abort(reason) {
+			if (this.signal.aborted) return;
+			this.signal.reason = reason;
+			this.signal.aborted = true;
+			for (const fn of this.signal._onabort) fn(reason);
+			this.signal.onabort?.(reason);
+		}
+	};
+	let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+	const warnACPolyfill = () => {
+		if (!printACPolyfillWarning) return;
+		printACPolyfillWarning = false;
+		emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
+	};
+}
+/* c8 ignore stop */
+const shouldWarn = (code) => !warned.has(code);
+const TYPE = Symbol("type");
+const isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+/* c8 ignore start */
+const getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+/* c8 ignore stop */
+var ZeroArray = class extends Array {
+	constructor(size) {
+		super(size);
+		this.fill(0);
+	}
+};
+var Stack = class Stack {
+	heap;
+	length;
+	static #constructing = false;
+	static create(max) {
+		const HeapCls = getUintArray(max);
+		if (!HeapCls) return [];
+		Stack.#constructing = true;
+		const s = new Stack(max, HeapCls);
+		Stack.#constructing = false;
+		return s;
+	}
+	constructor(max, HeapCls) {
+		/* c8 ignore start */
+		if (!Stack.#constructing) throw new TypeError("instantiate Stack using Stack.create(n)");
+		/* c8 ignore stop */
+		this.heap = new HeapCls(max);
+		this.length = 0;
+	}
+	push(n) {
+		this.heap[this.length++] = n;
+	}
+	pop() {
+		return this.heap[--this.length];
+	}
+};
+/**
+* Default export, the thing you're using this module to get.
+*
+* The `K` and `V` types define the key and value types, respectively. The
+* optional `FC` type defines the type of the `context` object passed to
+* `cache.fetch()` and `cache.memo()`.
+*
+* Keys and values **must not** be `null` or `undefined`.
+*
+* All properties from the options object (with the exception of `max`,
+* `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+* added as normal public members. (The listed options are read-only getters.)
+*
+* Changing any of these will alter the defaults for subsequent method calls.
+*/
+var LRUCache = class LRUCache {
+	#max;
+	#maxSize;
+	#dispose;
+	#disposeAfter;
+	#fetchMethod;
+	#memoMethod;
+	/**
+	* {@link LRUCache.OptionsBase.ttl}
+	*/
+	ttl;
+	/**
+	* {@link LRUCache.OptionsBase.ttlResolution}
+	*/
+	ttlResolution;
+	/**
+	* {@link LRUCache.OptionsBase.ttlAutopurge}
+	*/
+	ttlAutopurge;
+	/**
+	* {@link LRUCache.OptionsBase.updateAgeOnGet}
+	*/
+	updateAgeOnGet;
+	/**
+	* {@link LRUCache.OptionsBase.updateAgeOnHas}
+	*/
+	updateAgeOnHas;
+	/**
+	* {@link LRUCache.OptionsBase.allowStale}
+	*/
+	allowStale;
+	/**
+	* {@link LRUCache.OptionsBase.noDisposeOnSet}
+	*/
+	noDisposeOnSet;
+	/**
+	* {@link LRUCache.OptionsBase.noUpdateTTL}
+	*/
+	noUpdateTTL;
+	/**
+	* {@link LRUCache.OptionsBase.maxEntrySize}
+	*/
+	maxEntrySize;
+	/**
+	* {@link LRUCache.OptionsBase.sizeCalculation}
+	*/
+	sizeCalculation;
+	/**
+	* {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+	*/
+	noDeleteOnFetchRejection;
+	/**
+	* {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+	*/
+	noDeleteOnStaleGet;
+	/**
+	* {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+	*/
+	allowStaleOnFetchAbort;
+	/**
+	* {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+	*/
+	allowStaleOnFetchRejection;
+	/**
+	* {@link LRUCache.OptionsBase.ignoreFetchAbort}
+	*/
+	ignoreFetchAbort;
+	#size;
+	#calculatedSize;
+	#keyMap;
+	#keyList;
+	#valList;
+	#next;
+	#prev;
+	#head;
+	#tail;
+	#free;
+	#disposed;
+	#sizes;
+	#starts;
+	#ttls;
+	#hasDispose;
+	#hasFetchMethod;
+	#hasDisposeAfter;
+	/**
+	* Do not call this method unless you need to inspect the
+	* inner workings of the cache.  If anything returned by this
+	* object is modified in any way, strange breakage may occur.
+	*
+	* These fields are private for a reason!
+	*
+	* @internal
+	*/
+	static unsafeExposeInternals(c) {
+		return {
+			starts: c.#starts,
+			ttls: c.#ttls,
+			sizes: c.#sizes,
+			keyMap: c.#keyMap,
+			keyList: c.#keyList,
+			valList: c.#valList,
+			next: c.#next,
+			prev: c.#prev,
+			get head() {
+				return c.#head;
+			},
+			get tail() {
+				return c.#tail;
+			},
+			free: c.#free,
+			isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
+			backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+			moveToTail: (index) => c.#moveToTail(index),
+			indexes: (options) => c.#indexes(options),
+			rindexes: (options) => c.#rindexes(options),
+			isStale: (index) => c.#isStale(index)
+		};
+	}
+	/**
+	* {@link LRUCache.OptionsBase.max} (read-only)
+	*/
+	get max() {
+		return this.#max;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.maxSize} (read-only)
+	*/
+	get maxSize() {
+		return this.#maxSize;
+	}
+	/**
+	* The total computed size of items in the cache (read-only)
+	*/
+	get calculatedSize() {
+		return this.#calculatedSize;
+	}
+	/**
+	* The number of items stored in the cache (read-only)
+	*/
+	get size() {
+		return this.#size;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+	*/
+	get fetchMethod() {
+		return this.#fetchMethod;
+	}
+	get memoMethod() {
+		return this.#memoMethod;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.dispose} (read-only)
+	*/
+	get dispose() {
+		return this.#dispose;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+	*/
+	get disposeAfter() {
+		return this.#disposeAfter;
+	}
+	constructor(options) {
+		const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+		if (max !== 0 && !isPosInt(max)) throw new TypeError("max option must be a nonnegative integer");
+		const UintArray = max ? getUintArray(max) : Array;
+		if (!UintArray) throw new Error("invalid max value: " + max);
+		this.#max = max;
+		this.#maxSize = maxSize;
+		this.maxEntrySize = maxEntrySize || this.#maxSize;
+		this.sizeCalculation = sizeCalculation;
+		if (this.sizeCalculation) {
+			if (!this.#maxSize && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+			if (typeof this.sizeCalculation !== "function") throw new TypeError("sizeCalculation set to non-function");
+		}
+		if (memoMethod !== void 0 && typeof memoMethod !== "function") throw new TypeError("memoMethod must be a function if defined");
+		this.#memoMethod = memoMethod;
+		if (fetchMethod !== void 0 && typeof fetchMethod !== "function") throw new TypeError("fetchMethod must be a function if specified");
+		this.#fetchMethod = fetchMethod;
+		this.#hasFetchMethod = !!fetchMethod;
+		this.#keyMap = new Map();
+		this.#keyList = new Array(max).fill(void 0);
+		this.#valList = new Array(max).fill(void 0);
+		this.#next = new UintArray(max);
+		this.#prev = new UintArray(max);
+		this.#head = 0;
+		this.#tail = 0;
+		this.#free = Stack.create(max);
+		this.#size = 0;
+		this.#calculatedSize = 0;
+		if (typeof dispose === "function") this.#dispose = dispose;
+		if (typeof disposeAfter === "function") {
+			this.#disposeAfter = disposeAfter;
+			this.#disposed = [];
+		} else {
+			this.#disposeAfter = void 0;
+			this.#disposed = void 0;
+		}
+		this.#hasDispose = !!this.#dispose;
+		this.#hasDisposeAfter = !!this.#disposeAfter;
+		this.noDisposeOnSet = !!noDisposeOnSet;
+		this.noUpdateTTL = !!noUpdateTTL;
+		this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+		this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+		this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+		this.ignoreFetchAbort = !!ignoreFetchAbort;
+		if (this.maxEntrySize !== 0) {
+			if (this.#maxSize !== 0) {
+				if (!isPosInt(this.#maxSize)) throw new TypeError("maxSize must be a positive integer if specified");
+			}
+			if (!isPosInt(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+			this.#initializeSizeTracking();
+		}
+		this.allowStale = !!allowStale;
+		this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+		this.updateAgeOnGet = !!updateAgeOnGet;
+		this.updateAgeOnHas = !!updateAgeOnHas;
+		this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+		this.ttlAutopurge = !!ttlAutopurge;
+		this.ttl = ttl || 0;
+		if (this.ttl) {
+			if (!isPosInt(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+			this.#initializeTTLTracking();
+		}
+		if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+		if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+			const code = "LRU_CACHE_UNBOUNDED";
+			if (shouldWarn(code)) {
+				warned.add(code);
+				const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
+				emitWarning(msg, "UnboundedCacheWarning", code, LRUCache);
+			}
+		}
+	}
+	/**
+	* Return the number of ms left in the item's TTL. If item is not in cache,
+	* returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+	*/
+	getRemainingTTL(key) {
+		return this.#keyMap.has(key) ? Infinity : 0;
+	}
+	#initializeTTLTracking() {
+		const ttls = new ZeroArray(this.#max);
+		const starts = new ZeroArray(this.#max);
+		this.#ttls = ttls;
+		this.#starts = starts;
+		this.#setItemTTL = (index, ttl, start = perf.now()) => {
+			starts[index] = ttl !== 0 ? start : 0;
+			ttls[index] = ttl;
+			if (ttl !== 0 && this.ttlAutopurge) {
+				const t = setTimeout(() => {
+					if (this.#isStale(index)) this.#delete(this.#keyList[index], "expire");
+				}, ttl + 1);
+				/* c8 ignore start */
+				if (t.unref) t.unref();
+			}
+		};
+		this.#updateItemAge = (index) => {
+			starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+		};
+		this.#statusTTL = (status, index) => {
+			if (ttls[index]) {
+				const ttl = ttls[index];
+				const start = starts[index];
+				/* c8 ignore next */
+				if (!ttl || !start) return;
+				status.ttl = ttl;
+				status.start = start;
+				status.now = cachedNow || getNow();
+				const age = status.now - start;
+				status.remainingTTL = ttl - age;
+			}
+		};
+		let cachedNow = 0;
+		const getNow = () => {
+			const n = perf.now();
+			if (this.ttlResolution > 0) {
+				cachedNow = n;
+				const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
+				/* c8 ignore start */
+				if (t.unref) t.unref();
+			}
+			return n;
+		};
+		this.getRemainingTTL = (key) => {
+			const index = this.#keyMap.get(key);
+			if (index === void 0) return 0;
+			const ttl = ttls[index];
+			const start = starts[index];
+			if (!ttl || !start) return Infinity;
+			const age = (cachedNow || getNow()) - start;
+			return ttl - age;
+		};
+		this.#isStale = (index) => {
+			const s = starts[index];
+			const t = ttls[index];
+			return !!t && !!s && (cachedNow || getNow()) - s > t;
+		};
+	}
+	#updateItemAge = () => {};
+	#statusTTL = () => {};
+	#setItemTTL = () => {};
+	/* c8 ignore stop */
+	#isStale = () => false;
+	#initializeSizeTracking() {
+		const sizes = new ZeroArray(this.#max);
+		this.#calculatedSize = 0;
+		this.#sizes = sizes;
+		this.#removeItemSize = (index) => {
+			this.#calculatedSize -= sizes[index];
+			sizes[index] = 0;
+		};
+		this.#requireSize = (k, v, size, sizeCalculation) => {
+			if (this.#isBackgroundFetch(v)) return 0;
+			if (!isPosInt(size)) if (sizeCalculation) {
+				if (typeof sizeCalculation !== "function") throw new TypeError("sizeCalculation must be a function");
+				size = sizeCalculation(v, k);
+				if (!isPosInt(size)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+			} else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+			return size;
+		};
+		this.#addItemSize = (index, size, status) => {
+			sizes[index] = size;
+			if (this.#maxSize) {
+				const maxSize = this.#maxSize - sizes[index];
+				while (this.#calculatedSize > maxSize) this.#evict(true);
+			}
+			this.#calculatedSize += sizes[index];
+			if (status) {
+				status.entrySize = size;
+				status.totalCalculatedSize = this.#calculatedSize;
+			}
+		};
+	}
+	#removeItemSize = (_i) => {};
+	#addItemSize = (_i, _s, _st) => {};
+	#requireSize = (_k, _v, size, sizeCalculation) => {
+		if (size || sizeCalculation) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+		return 0;
+	};
+	*#indexes({ allowStale = this.allowStale } = {}) {
+		if (this.#size) for (let i = this.#tail;;) {
+			if (!this.#isValidIndex(i)) break;
+			if (allowStale || !this.#isStale(i)) yield i;
+			if (i === this.#head) break;
+			else i = this.#prev[i];
+		}
+	}
+	*#rindexes({ allowStale = this.allowStale } = {}) {
+		if (this.#size) for (let i = this.#head;;) {
+			if (!this.#isValidIndex(i)) break;
+			if (allowStale || !this.#isStale(i)) yield i;
+			if (i === this.#tail) break;
+			else i = this.#next[i];
+		}
+	}
+	#isValidIndex(index) {
+		return index !== void 0 && this.#keyMap.get(this.#keyList[index]) === index;
+	}
+	/**
+	* Return a generator yielding `[key, value]` pairs,
+	* in order from most recently used to least recently used.
+	*/
+	*entries() {
+		for (const i of this.#indexes()) if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield [this.#keyList[i], this.#valList[i]];
+	}
+	/**
+	* Inverse order version of {@link LRUCache.entries}
+	*
+	* Return a generator yielding `[key, value]` pairs,
+	* in order from least recently used to most recently used.
+	*/
+	*rentries() {
+		for (const i of this.#rindexes()) if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield [this.#keyList[i], this.#valList[i]];
+	}
+	/**
+	* Return a generator yielding the keys in the cache,
+	* in order from most recently used to least recently used.
+	*/
+	*keys() {
+		for (const i of this.#indexes()) {
+			const k = this.#keyList[i];
+			if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+		}
+	}
+	/**
+	* Inverse order version of {@link LRUCache.keys}
+	*
+	* Return a generator yielding the keys in the cache,
+	* in order from least recently used to most recently used.
+	*/
+	*rkeys() {
+		for (const i of this.#rindexes()) {
+			const k = this.#keyList[i];
+			if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+		}
+	}
+	/**
+	* Return a generator yielding the values in the cache,
+	* in order from most recently used to least recently used.
+	*/
+	*values() {
+		for (const i of this.#indexes()) {
+			const v = this.#valList[i];
+			if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+		}
+	}
+	/**
+	* Inverse order version of {@link LRUCache.values}
+	*
+	* Return a generator yielding the values in the cache,
+	* in order from least recently used to most recently used.
+	*/
+	*rvalues() {
+		for (const i of this.#rindexes()) {
+			const v = this.#valList[i];
+			if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+		}
+	}
+	/**
+	* Iterating over the cache itself yields the same results as
+	* {@link LRUCache.entries}
+	*/
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	/**
+	* A String value that is used in the creation of the default string
+	* description of an object. Called by the built-in method
+	* `Object.prototype.toString`.
+	*/
+	[Symbol.toStringTag] = "LRUCache";
+	/**
+	* Find a value for which the supplied fn method returns a truthy value,
+	* similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+	*/
+	find(fn, getOptions = {}) {
+		for (const i of this.#indexes()) {
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0) continue;
+			if (fn(value, this.#keyList[i], this)) return this.get(this.#keyList[i], getOptions);
+		}
+	}
+	/**
+	* Call the supplied function on each item in the cache, in order from most
+	* recently used to least recently used.
+	*
+	* `fn` is called as `fn(value, key, cache)`.
+	*
+	* If `thisp` is provided, function will be called in the `this`-context of
+	* the provided object, or the cache if no `thisp` object is provided.
+	*
+	* Does not update age or recenty of use, or iterate over stale values.
+	*/
+	forEach(fn, thisp = this) {
+		for (const i of this.#indexes()) {
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0) continue;
+			fn.call(thisp, value, this.#keyList[i], this);
+		}
+	}
+	/**
+	* The same as {@link LRUCache.forEach} but items are iterated over in
+	* reverse order.  (ie, less recently used items are iterated over first.)
+	*/
+	rforEach(fn, thisp = this) {
+		for (const i of this.#rindexes()) {
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0) continue;
+			fn.call(thisp, value, this.#keyList[i], this);
+		}
+	}
+	/**
+	* Delete any stale entries. Returns true if anything was removed,
+	* false otherwise.
+	*/
+	purgeStale() {
+		let deleted = false;
+		for (const i of this.#rindexes({ allowStale: true })) if (this.#isStale(i)) {
+			this.#delete(this.#keyList[i], "expire");
+			deleted = true;
+		}
+		return deleted;
+	}
+	/**
+	* Get the extended info about a given entry, to get its value, size, and
+	* TTL info simultaneously. Returns `undefined` if the key is not present.
+	*
+	* Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+	* serialization, the `start` value is always the current timestamp, and the
+	* `ttl` is a calculated remaining time to live (negative if expired).
+	*
+	* Always returns stale values, if their info is found in the cache, so be
+	* sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+	* if relevant.
+	*/
+	info(key) {
+		const i = this.#keyMap.get(key);
+		if (i === void 0) return void 0;
+		const v = this.#valList[i];
+		const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+		if (value === void 0) return void 0;
+		const entry = { value };
+		if (this.#ttls && this.#starts) {
+			const ttl = this.#ttls[i];
+			const start = this.#starts[i];
+			if (ttl && start) {
+				const remain = ttl - (perf.now() - start);
+				entry.ttl = remain;
+				entry.start = Date.now();
+			}
+		}
+		if (this.#sizes) entry.size = this.#sizes[i];
+		return entry;
+	}
+	/**
+	* Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+	* passed to {@link LRLUCache#load}.
+	*
+	* The `start` fields are calculated relative to a portable `Date.now()`
+	* timestamp, even if `performance.now()` is available.
+	*
+	* Stale entries are always included in the `dump`, even if
+	* {@link LRUCache.OptionsBase.allowStale} is false.
+	*
+	* Note: this returns an actual array, not a generator, so it can be more
+	* easily passed around.
+	*/
+	dump() {
+		const arr = [];
+		for (const i of this.#indexes({ allowStale: true })) {
+			const key = this.#keyList[i];
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0 || key === void 0) continue;
+			const entry = { value };
+			if (this.#ttls && this.#starts) {
+				entry.ttl = this.#ttls[i];
+				const age = perf.now() - this.#starts[i];
+				entry.start = Math.floor(Date.now() - age);
+			}
+			if (this.#sizes) entry.size = this.#sizes[i];
+			arr.unshift([key, entry]);
+		}
+		return arr;
+	}
+	/**
+	* Reset the cache and load in the items in entries in the order listed.
+	*
+	* The shape of the resulting cache may be different if the same options are
+	* not used in both caches.
+	*
+	* The `start` fields are assumed to be calculated relative to a portable
+	* `Date.now()` timestamp, even if `performance.now()` is available.
+	*/
+	load(arr) {
+		this.clear();
+		for (const [key, entry] of arr) {
+			if (entry.start) {
+				const age = Date.now() - entry.start;
+				entry.start = perf.now() - age;
+			}
+			this.set(key, entry.value, entry);
+		}
+	}
+	/**
+	* Add a value to the cache.
+	*
+	* Note: if `undefined` is specified as a value, this is an alias for
+	* {@link LRUCache#delete}
+	*
+	* Fields on the {@link LRUCache.SetOptions} options param will override
+	* their corresponding values in the constructor options for the scope
+	* of this single `set()` operation.
+	*
+	* If `start` is provided, then that will set the effective start
+	* time for the TTL calculation. Note that this must be a previous
+	* value of `performance.now()` if supported, or a previous value of
+	* `Date.now()` if not.
+	*
+	* Options object may also include `size`, which will prevent
+	* calling the `sizeCalculation` function and just use the specified
+	* number if it is a positive integer, and `noDisposeOnSet` which
+	* will prevent calling a `dispose` function in the case of
+	* overwrites.
+	*
+	* If the `size` (or return value of `sizeCalculation`) for a given
+	* entry is greater than `maxEntrySize`, then the item will not be
+	* added to the cache.
+	*
+	* Will update the recency of the entry.
+	*
+	* If the value is `undefined`, then this is an alias for
+	* `cache.delete(key)`. `undefined` is never stored in the cache.
+	*/
+	set(k, v, setOptions = {}) {
+		if (v === void 0) {
+			this.delete(k);
+			return this;
+		}
+		const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
+		let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+		const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
+		if (this.maxEntrySize && size > this.maxEntrySize) {
+			if (status) {
+				status.set = "miss";
+				status.maxEntrySizeExceeded = true;
+			}
+			this.#delete(k, "set");
+			return this;
+		}
+		let index = this.#size === 0 ? void 0 : this.#keyMap.get(k);
+		if (index === void 0) {
+			index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
+			this.#keyList[index] = k;
+			this.#valList[index] = v;
+			this.#keyMap.set(k, index);
+			this.#next[this.#tail] = index;
+			this.#prev[index] = this.#tail;
+			this.#tail = index;
+			this.#size++;
+			this.#addItemSize(index, size, status);
+			if (status) status.set = "add";
+			noUpdateTTL = false;
+		} else {
+			this.#moveToTail(index);
+			const oldVal = this.#valList[index];
+			if (v !== oldVal) {
+				if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+					oldVal.__abortController.abort(new Error("replaced"));
+					const { __staleWhileFetching: s } = oldVal;
+					if (s !== void 0 && !noDisposeOnSet) {
+						if (this.#hasDispose) this.#dispose?.(s, k, "set");
+						if (this.#hasDisposeAfter) this.#disposed?.push([
+							s,
+							k,
+							"set"
+						]);
+					}
+				} else if (!noDisposeOnSet) {
+					if (this.#hasDispose) this.#dispose?.(oldVal, k, "set");
+					if (this.#hasDisposeAfter) this.#disposed?.push([
+						oldVal,
+						k,
+						"set"
+					]);
+				}
+				this.#removeItemSize(index);
+				this.#addItemSize(index, size, status);
+				this.#valList[index] = v;
+				if (status) {
+					status.set = "replace";
+					const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
+					if (oldValue !== void 0) status.oldValue = oldValue;
+				}
+			} else if (status) status.set = "update";
+		}
+		if (ttl !== 0 && !this.#ttls) this.#initializeTTLTracking();
+		if (this.#ttls) {
+			if (!noUpdateTTL) this.#setItemTTL(index, ttl, start);
+			if (status) this.#statusTTL(status, index);
+		}
+		if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+			const dt = this.#disposed;
+			let task;
+			while (task = dt?.shift()) this.#disposeAfter?.(...task);
+		}
+		return this;
+	}
+	/**
+	* Evict the least recently used item, returning its value or
+	* `undefined` if cache is empty.
+	*/
+	pop() {
+		try {
+			while (this.#size) {
+				const val = this.#valList[this.#head];
+				this.#evict(true);
+				if (this.#isBackgroundFetch(val)) {
+					if (val.__staleWhileFetching) return val.__staleWhileFetching;
+				} else if (val !== void 0) return val;
+			}
+		} finally {
+			if (this.#hasDisposeAfter && this.#disposed) {
+				const dt = this.#disposed;
+				let task;
+				while (task = dt?.shift()) this.#disposeAfter?.(...task);
+			}
+		}
+	}
+	#evict(free) {
+		const head = this.#head;
+		const k = this.#keyList[head];
+		const v = this.#valList[head];
+		if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) v.__abortController.abort(new Error("evicted"));
+		else if (this.#hasDispose || this.#hasDisposeAfter) {
+			if (this.#hasDispose) this.#dispose?.(v, k, "evict");
+			if (this.#hasDisposeAfter) this.#disposed?.push([
+				v,
+				k,
+				"evict"
+			]);
+		}
+		this.#removeItemSize(head);
+		if (free) {
+			this.#keyList[head] = void 0;
+			this.#valList[head] = void 0;
+			this.#free.push(head);
+		}
+		if (this.#size === 1) {
+			this.#head = this.#tail = 0;
+			this.#free.length = 0;
+		} else this.#head = this.#next[head];
+		this.#keyMap.delete(k);
+		this.#size--;
+		return head;
+	}
+	/**
+	* Check if a key is in the cache, without updating the recency of use.
+	* Will return false if the item is stale, even though it is technically
+	* in the cache.
+	*
+	* Check if a key is in the cache, without updating the recency of
+	* use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+	* to `true` in either the options or the constructor.
+	*
+	* Will return `false` if the item is stale, even though it is technically in
+	* the cache. The difference can be determined (if it matters) by using a
+	* `status` argument, and inspecting the `has` field.
+	*
+	* Will not update item age unless
+	* {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+	*/
+	has(k, hasOptions = {}) {
+		const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+		const index = this.#keyMap.get(k);
+		if (index !== void 0) {
+			const v = this.#valList[index];
+			if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === void 0) return false;
+			if (!this.#isStale(index)) {
+				if (updateAgeOnHas) this.#updateItemAge(index);
+				if (status) {
+					status.has = "hit";
+					this.#statusTTL(status, index);
+				}
+				return true;
+			} else if (status) {
+				status.has = "stale";
+				this.#statusTTL(status, index);
+			}
+		} else if (status) status.has = "miss";
+		return false;
+	}
+	/**
+	* Like {@link LRUCache#get} but doesn't update recency or delete stale
+	* items.
+	*
+	* Returns `undefined` if the item is stale, unless
+	* {@link LRUCache.OptionsBase.allowStale} is set.
+	*/
+	peek(k, peekOptions = {}) {
+		const { allowStale = this.allowStale } = peekOptions;
+		const index = this.#keyMap.get(k);
+		if (index === void 0 || !allowStale && this.#isStale(index)) return;
+		const v = this.#valList[index];
+		return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+	}
+	#backgroundFetch(k, index, options, context) {
+		const v = index === void 0 ? void 0 : this.#valList[index];
+		if (this.#isBackgroundFetch(v)) return v;
+		const ac = new AC();
+		const { signal } = options;
+		signal?.addEventListener("abort", () => ac.abort(signal.reason), { signal: ac.signal });
+		const fetchOpts = {
+			signal: ac.signal,
+			options,
+			context
+		};
+		const cb = (v$1, updateCache = false) => {
+			const { aborted } = ac.signal;
+			const ignoreAbort = options.ignoreFetchAbort && v$1 !== void 0;
+			if (options.status) if (aborted && !updateCache) {
+				options.status.fetchAborted = true;
+				options.status.fetchError = ac.signal.reason;
+				if (ignoreAbort) options.status.fetchAbortIgnored = true;
+			} else options.status.fetchResolved = true;
+			if (aborted && !ignoreAbort && !updateCache) return fetchFail(ac.signal.reason);
+			const bf$1 = p;
+			if (this.#valList[index] === p) if (v$1 === void 0) if (bf$1.__staleWhileFetching) this.#valList[index] = bf$1.__staleWhileFetching;
+			else this.#delete(k, "fetch");
+			else {
+				if (options.status) options.status.fetchUpdated = true;
+				this.set(k, v$1, fetchOpts.options);
+			}
+			return v$1;
+		};
+		const eb = (er) => {
+			if (options.status) {
+				options.status.fetchRejected = true;
+				options.status.fetchError = er;
+			}
+			return fetchFail(er);
+		};
+		const fetchFail = (er) => {
+			const { aborted } = ac.signal;
+			const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+			const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+			const noDelete = allowStale || options.noDeleteOnFetchRejection;
+			const bf$1 = p;
+			if (this.#valList[index] === p) {
+				const del = !noDelete || bf$1.__staleWhileFetching === void 0;
+				if (del) this.#delete(k, "fetch");
+				else if (!allowStaleAborted) this.#valList[index] = bf$1.__staleWhileFetching;
+			}
+			if (allowStale) {
+				if (options.status && bf$1.__staleWhileFetching !== void 0) options.status.returnedStale = true;
+				return bf$1.__staleWhileFetching;
+			} else if (bf$1.__returned === bf$1) throw er;
+		};
+		const pcall = (res, rej) => {
+			const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+			if (fmp && fmp instanceof Promise) fmp.then((v$1) => res(v$1 === void 0 ? void 0 : v$1), rej);
+			ac.signal.addEventListener("abort", () => {
+				if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+					res(void 0);
+					if (options.allowStaleOnFetchAbort) res = (v$1) => cb(v$1, true);
+				}
+			});
+		};
+		if (options.status) options.status.fetchDispatched = true;
+		const p = new Promise(pcall).then(cb, eb);
+		const bf = Object.assign(p, {
+			__abortController: ac,
+			__staleWhileFetching: v,
+			__returned: void 0
+		});
+		if (index === void 0) {
+			this.set(k, bf, {
+				...fetchOpts.options,
+				status: void 0
+			});
+			index = this.#keyMap.get(k);
+		} else this.#valList[index] = bf;
+		return bf;
+	}
+	#isBackgroundFetch(p) {
+		if (!this.#hasFetchMethod) return false;
+		const b = p;
+		return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC;
+	}
+	async fetch(k, fetchOptions = {}) {
+		const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal } = fetchOptions;
+		if (!this.#hasFetchMethod) {
+			if (status) status.fetch = "get";
+			return this.get(k, {
+				allowStale,
+				updateAgeOnGet,
+				noDeleteOnStaleGet,
+				status
+			});
+		}
+		const options = {
+			allowStale,
+			updateAgeOnGet,
+			noDeleteOnStaleGet,
+			ttl,
+			noDisposeOnSet,
+			size,
+			sizeCalculation,
+			noUpdateTTL,
+			noDeleteOnFetchRejection,
+			allowStaleOnFetchRejection,
+			allowStaleOnFetchAbort,
+			ignoreFetchAbort,
+			status,
+			signal
+		};
+		let index = this.#keyMap.get(k);
+		if (index === void 0) {
+			if (status) status.fetch = "miss";
+			const p = this.#backgroundFetch(k, index, options, context);
+			return p.__returned = p;
+		} else {
+			const v = this.#valList[index];
+			if (this.#isBackgroundFetch(v)) {
+				const stale = allowStale && v.__staleWhileFetching !== void 0;
+				if (status) {
+					status.fetch = "inflight";
+					if (stale) status.returnedStale = true;
+				}
+				return stale ? v.__staleWhileFetching : v.__returned = v;
+			}
+			const isStale = this.#isStale(index);
+			if (!forceRefresh && !isStale) {
+				if (status) status.fetch = "hit";
+				this.#moveToTail(index);
+				if (updateAgeOnGet) this.#updateItemAge(index);
+				if (status) this.#statusTTL(status, index);
+				return v;
+			}
+			const p = this.#backgroundFetch(k, index, options, context);
+			const hasStale = p.__staleWhileFetching !== void 0;
+			const staleVal = hasStale && allowStale;
+			if (status) {
+				status.fetch = isStale ? "stale" : "refresh";
+				if (staleVal && isStale) status.returnedStale = true;
+			}
+			return staleVal ? p.__staleWhileFetching : p.__returned = p;
+		}
+	}
+	async forceFetch(k, fetchOptions = {}) {
+		const v = await this.fetch(k, fetchOptions);
+		if (v === void 0) throw new Error("fetch() returned undefined");
+		return v;
+	}
+	memo(k, memoOptions = {}) {
+		const memoMethod = this.#memoMethod;
+		if (!memoMethod) throw new Error("no memoMethod provided to constructor");
+		const { context, forceRefresh,...options } = memoOptions;
+		const v = this.get(k, options);
+		if (!forceRefresh && v !== void 0) return v;
+		const vv = memoMethod(k, v, {
+			options,
+			context
+		});
+		this.set(k, vv, options);
+		return vv;
+	}
+	/**
+	* Return a value from the cache. Will update the recency of the cache
+	* entry found.
+	*
+	* If the key is not found, get() will return `undefined`.
+	*/
+	get(k, getOptions = {}) {
+		const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+		const index = this.#keyMap.get(k);
+		if (index !== void 0) {
+			const value = this.#valList[index];
+			const fetching = this.#isBackgroundFetch(value);
+			if (status) this.#statusTTL(status, index);
+			if (this.#isStale(index)) {
+				if (status) status.get = "stale";
+				if (!fetching) {
+					if (!noDeleteOnStaleGet) this.#delete(k, "expire");
+					if (status && allowStale) status.returnedStale = true;
+					return allowStale ? value : void 0;
+				} else {
+					if (status && allowStale && value.__staleWhileFetching !== void 0) status.returnedStale = true;
+					return allowStale ? value.__staleWhileFetching : void 0;
+				}
+			} else {
+				if (status) status.get = "hit";
+				if (fetching) return value.__staleWhileFetching;
+				this.#moveToTail(index);
+				if (updateAgeOnGet) this.#updateItemAge(index);
+				return value;
+			}
+		} else if (status) status.get = "miss";
+	}
+	#connect(p, n) {
+		this.#prev[n] = p;
+		this.#next[p] = n;
+	}
+	#moveToTail(index) {
+		if (index !== this.#tail) {
+			if (index === this.#head) this.#head = this.#next[index];
+			else this.#connect(this.#prev[index], this.#next[index]);
+			this.#connect(this.#tail, index);
+			this.#tail = index;
+		}
+	}
+	/**
+	* Deletes a key out of the cache.
+	*
+	* Returns true if the key was deleted, false otherwise.
+	*/
+	delete(k) {
+		return this.#delete(k, "delete");
+	}
+	#delete(k, reason) {
+		let deleted = false;
+		if (this.#size !== 0) {
+			const index = this.#keyMap.get(k);
+			if (index !== void 0) {
+				deleted = true;
+				if (this.#size === 1) this.#clear(reason);
+				else {
+					this.#removeItemSize(index);
+					const v = this.#valList[index];
+					if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error("deleted"));
+					else if (this.#hasDispose || this.#hasDisposeAfter) {
+						if (this.#hasDispose) this.#dispose?.(v, k, reason);
+						if (this.#hasDisposeAfter) this.#disposed?.push([
+							v,
+							k,
+							reason
+						]);
+					}
+					this.#keyMap.delete(k);
+					this.#keyList[index] = void 0;
+					this.#valList[index] = void 0;
+					if (index === this.#tail) this.#tail = this.#prev[index];
+					else if (index === this.#head) this.#head = this.#next[index];
+					else {
+						const pi = this.#prev[index];
+						this.#next[pi] = this.#next[index];
+						const ni = this.#next[index];
+						this.#prev[ni] = this.#prev[index];
+					}
+					this.#size--;
+					this.#free.push(index);
+				}
+			}
+		}
+		if (this.#hasDisposeAfter && this.#disposed?.length) {
+			const dt = this.#disposed;
+			let task;
+			while (task = dt?.shift()) this.#disposeAfter?.(...task);
+		}
+		return deleted;
+	}
+	/**
+	* Clear the cache entirely, throwing away all values.
+	*/
+	clear() {
+		return this.#clear("delete");
+	}
+	#clear(reason) {
+		for (const index of this.#rindexes({ allowStale: true })) {
+			const v = this.#valList[index];
+			if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error("deleted"));
+			else {
+				const k = this.#keyList[index];
+				if (this.#hasDispose) this.#dispose?.(v, k, reason);
+				if (this.#hasDisposeAfter) this.#disposed?.push([
+					v,
+					k,
+					reason
+				]);
+			}
+		}
+		this.#keyMap.clear();
+		this.#valList.fill(void 0);
+		this.#keyList.fill(void 0);
+		if (this.#ttls && this.#starts) {
+			this.#ttls.fill(0);
+			this.#starts.fill(0);
+		}
+		if (this.#sizes) this.#sizes.fill(0);
+		this.#head = 0;
+		this.#tail = 0;
+		this.#free.length = 0;
+		this.#calculatedSize = 0;
+		this.#size = 0;
+		if (this.#hasDisposeAfter && this.#disposed) {
+			const dt = this.#disposed;
+			let task;
+			while (task = dt?.shift()) this.#disposeAfter?.(...task);
+		}
+	}
+};
+
+//#endregion
+//#region node_modules/path-scurry/dist/esm/index.js
+const realpathSync$2 = realpathSync$1.native;
+const defaultFS = {
+	lstatSync,
+	readdir: readdir$2,
+	readdirSync: readdirSync$1,
+	readlinkSync,
+	realpathSync: realpathSync$2,
+	promises: {
+		lstat,
+		readdir: readdir$1,
+		readlink,
+		realpath
+	}
+};
+const fsFromOption = (fsOption) => !fsOption || fsOption === defaultFS || fsOption === actualFS ? defaultFS : {
+	...defaultFS,
+	...fsOption,
+	promises: {
+		...defaultFS.promises,
+		...fsOption.promises || {}
+	}
+};
+const uncDriveRegexp = /^\\\\\?\\([a-z]:)\\?$/i;
+const uncToDrive = (rootPath) => rootPath.replace(/\//g, "\\").replace(uncDriveRegexp, "$1\\");
+const eitherSep = /[\\\/]/;
+const UNKNOWN = 0;
+const IFIFO = 1;
+const IFCHR = 2;
+const IFDIR = 4;
+const IFBLK = 6;
+const IFREG = 8;
+const IFLNK = 10;
+const IFSOCK = 12;
+const IFMT = 15;
+const IFMT_UNKNOWN = ~IFMT;
+const READDIR_CALLED = 16;
+const LSTAT_CALLED = 32;
+const ENOTDIR = 64;
+const ENOENT = 128;
+const ENOREADLINK = 256;
+const ENOREALPATH = 512;
+const ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
+const TYPEMASK = 1023;
+const entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
+const normalizeCache = new Map();
+const normalize = (s) => {
+	const c = normalizeCache.get(s);
+	if (c) return c;
+	const n = s.normalize("NFKD");
+	normalizeCache.set(s, n);
+	return n;
+};
+const normalizeNocaseCache = new Map();
+const normalizeNocase = (s) => {
+	const c = normalizeNocaseCache.get(s);
+	if (c) return c;
+	const n = normalize(s.toLowerCase());
+	normalizeNocaseCache.set(s, n);
+	return n;
+};
+/**
+* An LRUCache for storing resolved path strings or Path objects.
+* @internal
+*/
+var ResolveCache = class extends LRUCache {
+	constructor() {
+		super({ max: 256 });
+	}
+};
+/**
+* an LRUCache for storing child entries.
+* @internal
+*/
+var ChildrenCache = class extends LRUCache {
+	constructor(maxSize = 16 * 1024) {
+		super({
+			maxSize,
+			sizeCalculation: (a) => a.length + 1
+		});
+	}
+};
+const setAsCwd = Symbol("PathScurry setAsCwd");
+/**
+* Path objects are sort of like a super-powered
+* {@link https://nodejs.org/docs/latest/api/fs.html#class-fsdirent fs.Dirent}
+*
+* Each one represents a single filesystem entry on disk, which may or may not
+* exist. It includes methods for reading various types of information via
+* lstat, readlink, and readdir, and caches all information to the greatest
+* degree possible.
+*
+* Note that fs operations that would normally throw will instead return an
+* "empty" value. This is in order to prevent excessive overhead from error
+* stack traces.
+*/
+var PathBase = class {
+	/**
+	* the basename of this path
+	*
+	* **Important**: *always* test the path name against any test string
+	* usingthe {@link isNamed} method, and not by directly comparing this
+	* string. Otherwise, unicode path strings that the system sees as identical
+	* will not be properly treated as the same path, leading to incorrect
+	* behavior and possible security issues.
+	*/
+	name;
+	/**
+	* the Path entry corresponding to the path root.
+	*
+	* @internal
+	*/
+	root;
+	/**
+	* All roots found within the current PathScurry family
+	*
+	* @internal
+	*/
+	roots;
+	/**
+	* a reference to the parent path, or undefined in the case of root entries
+	*
+	* @internal
+	*/
+	parent;
+	/**
+	* boolean indicating whether paths are compared case-insensitively
+	* @internal
+	*/
+	nocase;
+	/**
+	* boolean indicating that this path is the current working directory
+	* of the PathScurry collection that contains it.
+	*/
+	isCWD = false;
+	#fs;
+	#dev;
+	get dev() {
+		return this.#dev;
+	}
+	#mode;
+	get mode() {
+		return this.#mode;
+	}
+	#nlink;
+	get nlink() {
+		return this.#nlink;
+	}
+	#uid;
+	get uid() {
+		return this.#uid;
+	}
+	#gid;
+	get gid() {
+		return this.#gid;
+	}
+	#rdev;
+	get rdev() {
+		return this.#rdev;
+	}
+	#blksize;
+	get blksize() {
+		return this.#blksize;
+	}
+	#ino;
+	get ino() {
+		return this.#ino;
+	}
+	#size;
+	get size() {
+		return this.#size;
+	}
+	#blocks;
+	get blocks() {
+		return this.#blocks;
+	}
+	#atimeMs;
+	get atimeMs() {
+		return this.#atimeMs;
+	}
+	#mtimeMs;
+	get mtimeMs() {
+		return this.#mtimeMs;
+	}
+	#ctimeMs;
+	get ctimeMs() {
+		return this.#ctimeMs;
+	}
+	#birthtimeMs;
+	get birthtimeMs() {
+		return this.#birthtimeMs;
+	}
+	#atime;
+	get atime() {
+		return this.#atime;
+	}
+	#mtime;
+	get mtime() {
+		return this.#mtime;
+	}
+	#ctime;
+	get ctime() {
+		return this.#ctime;
+	}
+	#birthtime;
+	get birthtime() {
+		return this.#birthtime;
+	}
+	#matchName;
+	#depth;
+	#fullpath;
+	#fullpathPosix;
+	#relative;
+	#relativePosix;
+	#type;
+	#children;
+	#linkTarget;
+	#realpath;
+	/**
+	* This property is for compatibility with the Dirent class as of
+	* Node v20, where Dirent['parentPath'] refers to the path of the
+	* directory that was passed to readdir. For root entries, it's the path
+	* to the entry itself.
+	*/
+	get parentPath() {
+		return (this.parent || this).fullpath();
+	}
+	/**
+	* Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,
+	* this property refers to the *parent* path, not the path object itself.
+	*/
+	get path() {
+		return this.parentPath;
+	}
+	/**
+	* Do not create new Path objects directly.  They should always be accessed
+	* via the PathScurry class or other methods on the Path class.
+	*
+	* @internal
+	*/
+	constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+		this.name = name;
+		this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
+		this.#type = type & TYPEMASK;
+		this.nocase = nocase;
+		this.roots = roots;
+		this.root = root || this;
+		this.#children = children;
+		this.#fullpath = opts.fullpath;
+		this.#relative = opts.relative;
+		this.#relativePosix = opts.relativePosix;
+		this.parent = opts.parent;
+		if (this.parent) this.#fs = this.parent.#fs;
+		else this.#fs = fsFromOption(opts.fs);
+	}
+	/**
+	* Returns the depth of the Path object from its root.
+	*
+	* For example, a path at `/foo/bar` would have a depth of 2.
+	*/
+	depth() {
+		if (this.#depth !== void 0) return this.#depth;
+		if (!this.parent) return this.#depth = 0;
+		return this.#depth = this.parent.depth() + 1;
+	}
+	/**
+	* @internal
+	*/
+	childrenCache() {
+		return this.#children;
+	}
+	/**
+	* Get the Path object referenced by the string path, resolved from this Path
+	*/
+	resolve(path$4) {
+		if (!path$4) return this;
+		const rootPath = this.getRootString(path$4);
+		const dir = path$4.substring(rootPath.length);
+		const dirParts = dir.split(this.splitSep);
+		const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
+		return result;
+	}
+	#resolveParts(dirParts) {
+		let p = this;
+		for (const part of dirParts) p = p.child(part);
+		return p;
+	}
+	/**
+	* Returns the cached children Path objects, if still available.  If they
+	* have fallen out of the cache, then returns an empty array, and resets the
+	* READDIR_CALLED bit, so that future calls to readdir() will require an fs
+	* lookup.
+	*
+	* @internal
+	*/
+	children() {
+		const cached = this.#children.get(this);
+		if (cached) return cached;
+		const children = Object.assign([], { provisional: 0 });
+		this.#children.set(this, children);
+		this.#type &= ~READDIR_CALLED;
+		return children;
+	}
+	/**
+	* Resolves a path portion and returns or creates the child Path.
+	*
+	* Returns `this` if pathPart is `''` or `'.'`, or `parent` if pathPart is
+	* `'..'`.
+	*
+	* This should not be called directly.  If `pathPart` contains any path
+	* separators, it will lead to unsafe undefined behavior.
+	*
+	* Use `Path.resolve()` instead.
+	*
+	* @internal
+	*/
+	child(pathPart, opts) {
+		if (pathPart === "" || pathPart === ".") return this;
+		if (pathPart === "..") return this.parent || this;
+		const children = this.children();
+		const name = this.nocase ? normalizeNocase(pathPart) : normalize(pathPart);
+		for (const p of children) if (p.#matchName === name) return p;
+		const s = this.parent ? this.sep : "";
+		const fullpath = this.#fullpath ? this.#fullpath + s + pathPart : void 0;
+		const pchild = this.newChild(pathPart, UNKNOWN, {
+			...opts,
+			parent: this,
+			fullpath
+		});
+		if (!this.canReaddir()) pchild.#type |= ENOENT;
+		children.push(pchild);
+		return pchild;
+	}
+	/**
+	* The relative path from the cwd. If it does not share an ancestor with
+	* the cwd, then this ends up being equivalent to the fullpath()
+	*/
+	relative() {
+		if (this.isCWD) return "";
+		if (this.#relative !== void 0) return this.#relative;
+		const name = this.name;
+		const p = this.parent;
+		if (!p) return this.#relative = this.name;
+		const pv = p.relative();
+		return pv + (!pv || !p.parent ? "" : this.sep) + name;
+	}
+	/**
+	* The relative path from the cwd, using / as the path separator.
+	* If it does not share an ancestor with
+	* the cwd, then this ends up being equivalent to the fullpathPosix()
+	* On posix systems, this is identical to relative().
+	*/
+	relativePosix() {
+		if (this.sep === "/") return this.relative();
+		if (this.isCWD) return "";
+		if (this.#relativePosix !== void 0) return this.#relativePosix;
+		const name = this.name;
+		const p = this.parent;
+		if (!p) return this.#relativePosix = this.fullpathPosix();
+		const pv = p.relativePosix();
+		return pv + (!pv || !p.parent ? "" : "/") + name;
+	}
+	/**
+	* The fully resolved path string for this Path entry
+	*/
+	fullpath() {
+		if (this.#fullpath !== void 0) return this.#fullpath;
+		const name = this.name;
+		const p = this.parent;
+		if (!p) return this.#fullpath = this.name;
+		const pv = p.fullpath();
+		const fp = pv + (!p.parent ? "" : this.sep) + name;
+		return this.#fullpath = fp;
+	}
+	/**
+	* On platforms other than windows, this is identical to fullpath.
+	*
+	* On windows, this is overridden to return the forward-slash form of the
+	* full UNC path.
+	*/
+	fullpathPosix() {
+		if (this.#fullpathPosix !== void 0) return this.#fullpathPosix;
+		if (this.sep === "/") return this.#fullpathPosix = this.fullpath();
+		if (!this.parent) {
+			const p$1 = this.fullpath().replace(/\\/g, "/");
+			if (/^[a-z]:\//i.test(p$1)) return this.#fullpathPosix = `//?/${p$1}`;
+			else return this.#fullpathPosix = p$1;
+		}
+		const p = this.parent;
+		const pfpp = p.fullpathPosix();
+		const fpp = pfpp + (!pfpp || !p.parent ? "" : "/") + this.name;
+		return this.#fullpathPosix = fpp;
+	}
+	/**
+	* Is the Path of an unknown type?
+	*
+	* Note that we might know *something* about it if there has been a previous
+	* filesystem operation, for example that it does not exist, or is not a
+	* link, or whether it has child entries.
+	*/
+	isUnknown() {
+		return (this.#type & IFMT) === UNKNOWN;
+	}
+	isType(type) {
+		return this[`is${type}`]();
+	}
+	getType() {
+		return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
+		/* c8 ignore stop */
+	}
+	/**
+	* Is the Path a regular file?
+	*/
+	isFile() {
+		return (this.#type & IFMT) === IFREG;
+	}
+	/**
+	* Is the Path a directory?
+	*/
+	isDirectory() {
+		return (this.#type & IFMT) === IFDIR;
+	}
+	/**
+	* Is the path a character device?
+	*/
+	isCharacterDevice() {
+		return (this.#type & IFMT) === IFCHR;
+	}
+	/**
+	* Is the path a block device?
+	*/
+	isBlockDevice() {
+		return (this.#type & IFMT) === IFBLK;
+	}
+	/**
+	* Is the path a FIFO pipe?
+	*/
+	isFIFO() {
+		return (this.#type & IFMT) === IFIFO;
+	}
+	/**
+	* Is the path a socket?
+	*/
+	isSocket() {
+		return (this.#type & IFMT) === IFSOCK;
+	}
+	/**
+	* Is the path a symbolic link?
+	*/
+	isSymbolicLink() {
+		return (this.#type & IFLNK) === IFLNK;
+	}
+	/**
+	* Return the entry if it has been subject of a successful lstat, or
+	* undefined otherwise.
+	*
+	* Does not read the filesystem, so an undefined result *could* simply
+	* mean that we haven't called lstat on it.
+	*/
+	lstatCached() {
+		return this.#type & LSTAT_CALLED ? this : void 0;
+	}
+	/**
+	* Return the cached link target if the entry has been the subject of a
+	* successful readlink, or undefined otherwise.
+	*
+	* Does not read the filesystem, so an undefined result *could* just mean we
+	* don't have any cached data. Only use it if you are very sure that a
+	* readlink() has been called at some point.
+	*/
+	readlinkCached() {
+		return this.#linkTarget;
+	}
+	/**
+	* Returns the cached realpath target if the entry has been the subject
+	* of a successful realpath, or undefined otherwise.
+	*
+	* Does not read the filesystem, so an undefined result *could* just mean we
+	* don't have any cached data. Only use it if you are very sure that a
+	* realpath() has been called at some point.
+	*/
+	realpathCached() {
+		return this.#realpath;
+	}
+	/**
+	* Returns the cached child Path entries array if the entry has been the
+	* subject of a successful readdir(), or [] otherwise.
+	*
+	* Does not read the filesystem, so an empty array *could* just mean we
+	* don't have any cached data. Only use it if you are very sure that a
+	* readdir() has been called recently enough to still be valid.
+	*/
+	readdirCached() {
+		const children = this.children();
+		return children.slice(0, children.provisional);
+	}
+	/**
+	* Return true if it's worth trying to readlink.  Ie, we don't (yet) have
+	* any indication that readlink will definitely fail.
+	*
+	* Returns false if the path is known to not be a symlink, if a previous
+	* readlink failed, or if the entry does not exist.
+	*/
+	canReadlink() {
+		if (this.#linkTarget) return true;
+		if (!this.parent) return false;
+		const ifmt = this.#type & IFMT;
+		return !(ifmt !== UNKNOWN && ifmt !== IFLNK || this.#type & ENOREADLINK || this.#type & ENOENT);
+	}
+	/**
+	* Return true if readdir has previously been successfully called on this
+	* path, indicating that cachedReaddir() is likely valid.
+	*/
+	calledReaddir() {
+		return !!(this.#type & READDIR_CALLED);
+	}
+	/**
+	* Returns true if the path is known to not exist. That is, a previous lstat
+	* or readdir failed to verify its existence when that would have been
+	* expected, or a parent entry was marked either enoent or enotdir.
+	*/
+	isENOENT() {
+		return !!(this.#type & ENOENT);
+	}
+	/**
+	* Return true if the path is a match for the given path name.  This handles
+	* case sensitivity and unicode normalization.
+	*
+	* Note: even on case-sensitive systems, it is **not** safe to test the
+	* equality of the `.name` property to determine whether a given pathname
+	* matches, due to unicode normalization mismatches.
+	*
+	* Always use this method instead of testing the `path.name` property
+	* directly.
+	*/
+	isNamed(n) {
+		return !this.nocase ? this.#matchName === normalize(n) : this.#matchName === normalizeNocase(n);
+	}
+	/**
+	* Return the Path object corresponding to the target of a symbolic link.
+	*
+	* If the Path is not a symbolic link, or if the readlink call fails for any
+	* reason, `undefined` is returned.
+	*
+	* Result is cached, and thus may be outdated if the filesystem is mutated.
+	*/
+	async readlink() {
+		const target = this.#linkTarget;
+		if (target) return target;
+		if (!this.canReadlink()) return void 0;
+		/* c8 ignore start */
+		if (!this.parent) return void 0;
+		/* c8 ignore stop */
+		try {
+			const read = await this.#fs.promises.readlink(this.fullpath());
+			const linkTarget = (await this.parent.realpath())?.resolve(read);
+			if (linkTarget) return this.#linkTarget = linkTarget;
+		} catch (er) {
+			this.#readlinkFail(er.code);
+			return void 0;
+		}
+	}
+	/**
+	* Synchronous {@link PathBase.readlink}
+	*/
+	readlinkSync() {
+		const target = this.#linkTarget;
+		if (target) return target;
+		if (!this.canReadlink()) return void 0;
+		/* c8 ignore start */
+		if (!this.parent) return void 0;
+		/* c8 ignore stop */
+		try {
+			const read = this.#fs.readlinkSync(this.fullpath());
+			const linkTarget = this.parent.realpathSync()?.resolve(read);
+			if (linkTarget) return this.#linkTarget = linkTarget;
+		} catch (er) {
+			this.#readlinkFail(er.code);
+			return void 0;
+		}
+	}
+	#readdirSuccess(children) {
+		this.#type |= READDIR_CALLED;
+		for (let p = children.provisional; p < children.length; p++) {
+			const c = children[p];
+			if (c) c.#markENOENT();
+		}
+	}
+	#markENOENT() {
+		if (this.#type & ENOENT) return;
+		this.#type = (this.#type | ENOENT) & IFMT_UNKNOWN;
+		this.#markChildrenENOENT();
+	}
+	#markChildrenENOENT() {
+		const children = this.children();
+		children.provisional = 0;
+		for (const p of children) p.#markENOENT();
+	}
+	#markENOREALPATH() {
+		this.#type |= ENOREALPATH;
+		this.#markENOTDIR();
+	}
+	#markENOTDIR() {
+		/* c8 ignore start */
+		if (this.#type & ENOTDIR) return;
+		/* c8 ignore stop */
+		let t = this.#type;
+		if ((t & IFMT) === IFDIR) t &= IFMT_UNKNOWN;
+		this.#type = t | ENOTDIR;
+		this.#markChildrenENOENT();
+	}
+	#readdirFail(code = "") {
+		if (code === "ENOTDIR" || code === "EPERM") this.#markENOTDIR();
+		else if (code === "ENOENT") this.#markENOENT();
+		else this.children().provisional = 0;
+	}
+	#lstatFail(code = "") {
+		/* c8 ignore start */
+		if (code === "ENOTDIR") {
+			const p = this.parent;
+			p.#markENOTDIR();
+		} else if (code === "ENOENT")
+ /* c8 ignore stop */
+		this.#markENOENT();
+	}
+	#readlinkFail(code = "") {
+		let ter = this.#type;
+		ter |= ENOREADLINK;
+		if (code === "ENOENT") ter |= ENOENT;
+		if (code === "EINVAL" || code === "UNKNOWN") ter &= IFMT_UNKNOWN;
+		this.#type = ter;
+		/* c8 ignore start */
+		if (code === "ENOTDIR" && this.parent) this.parent.#markENOTDIR();
+		/* c8 ignore stop */
+	}
+	#readdirAddChild(e, c) {
+		return this.#readdirMaybePromoteChild(e, c) || this.#readdirAddNewChild(e, c);
+	}
+	#readdirAddNewChild(e, c) {
+		const type = entToType(e);
+		const child = this.newChild(e.name, type, { parent: this });
+		const ifmt = child.#type & IFMT;
+		if (ifmt !== IFDIR && ifmt !== IFLNK && ifmt !== UNKNOWN) child.#type |= ENOTDIR;
+		c.unshift(child);
+		c.provisional++;
+		return child;
+	}
+	#readdirMaybePromoteChild(e, c) {
+		for (let p = c.provisional; p < c.length; p++) {
+			const pchild = c[p];
+			const name = this.nocase ? normalizeNocase(e.name) : normalize(e.name);
+			if (name !== pchild.#matchName) continue;
+			return this.#readdirPromoteChild(e, pchild, p, c);
+		}
+	}
+	#readdirPromoteChild(e, p, index, c) {
+		const v = p.name;
+		p.#type = p.#type & IFMT_UNKNOWN | entToType(e);
+		if (v !== e.name) p.name = e.name;
+		if (index !== c.provisional) {
+			if (index === c.length - 1) c.pop();
+			else c.splice(index, 1);
+			c.unshift(p);
+		}
+		c.provisional++;
+		return p;
+	}
+	/**
+	* Call lstat() on this Path, and update all known information that can be
+	* determined.
+	*
+	* Note that unlike `fs.lstat()`, the returned value does not contain some
+	* information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
+	* information is required, you will need to call `fs.lstat` yourself.
+	*
+	* If the Path refers to a nonexistent file, or if the lstat call fails for
+	* any reason, `undefined` is returned.  Otherwise the updated Path object is
+	* returned.
+	*
+	* Results are cached, and thus may be out of date if the filesystem is
+	* mutated.
+	*/
+	async lstat() {
+		if ((this.#type & ENOENT) === 0) try {
+			this.#applyStat(await this.#fs.promises.lstat(this.fullpath()));
+			return this;
+		} catch (er) {
+			this.#lstatFail(er.code);
+		}
+	}
+	/**
+	* synchronous {@link PathBase.lstat}
+	*/
+	lstatSync() {
+		if ((this.#type & ENOENT) === 0) try {
+			this.#applyStat(this.#fs.lstatSync(this.fullpath()));
+			return this;
+		} catch (er) {
+			this.#lstatFail(er.code);
+		}
+	}
+	#applyStat(st) {
+		const { atime, atimeMs, birthtime, birthtimeMs, blksize, blocks, ctime, ctimeMs, dev, gid, ino, mode, mtime, mtimeMs, nlink, rdev, size, uid } = st;
+		this.#atime = atime;
+		this.#atimeMs = atimeMs;
+		this.#birthtime = birthtime;
+		this.#birthtimeMs = birthtimeMs;
+		this.#blksize = blksize;
+		this.#blocks = blocks;
+		this.#ctime = ctime;
+		this.#ctimeMs = ctimeMs;
+		this.#dev = dev;
+		this.#gid = gid;
+		this.#ino = ino;
+		this.#mode = mode;
+		this.#mtime = mtime;
+		this.#mtimeMs = mtimeMs;
+		this.#nlink = nlink;
+		this.#rdev = rdev;
+		this.#size = size;
+		this.#uid = uid;
+		const ifmt = entToType(st);
+		this.#type = this.#type & IFMT_UNKNOWN | ifmt | LSTAT_CALLED;
+		if (ifmt !== UNKNOWN && ifmt !== IFDIR && ifmt !== IFLNK) this.#type |= ENOTDIR;
+	}
+	#onReaddirCB = [];
+	#readdirCBInFlight = false;
+	#callOnReaddirCB(children) {
+		this.#readdirCBInFlight = false;
+		const cbs = this.#onReaddirCB.slice();
+		this.#onReaddirCB.length = 0;
+		cbs.forEach((cb) => cb(null, children));
+	}
+	/**
+	* Standard node-style callback interface to get list of directory entries.
+	*
+	* If the Path cannot or does not contain any children, then an empty array
+	* is returned.
+	*
+	* Results are cached, and thus may be out of date if the filesystem is
+	* mutated.
+	*
+	* @param cb The callback called with (er, entries).  Note that the `er`
+	* param is somewhat extraneous, as all readdir() errors are handled and
+	* simply result in an empty set of entries being returned.
+	* @param allowZalgo Boolean indicating that immediately known results should
+	* *not* be deferred with `queueMicrotask`. Defaults to `false`. Release
+	* zalgo at your peril, the dark pony lord is devious and unforgiving.
+	*/
+	readdirCB(cb, allowZalgo = false) {
+		if (!this.canReaddir()) {
+			if (allowZalgo) cb(null, []);
+			else queueMicrotask(() => cb(null, []));
+			return;
+		}
+		const children = this.children();
+		if (this.calledReaddir()) {
+			const c = children.slice(0, children.provisional);
+			if (allowZalgo) cb(null, c);
+			else queueMicrotask(() => cb(null, c));
+			return;
+		}
+		this.#onReaddirCB.push(cb);
+		if (this.#readdirCBInFlight) return;
+		this.#readdirCBInFlight = true;
+		const fullpath = this.fullpath();
+		this.#fs.readdir(fullpath, { withFileTypes: true }, (er, entries) => {
+			if (er) {
+				this.#readdirFail(er.code);
+				children.provisional = 0;
+			} else {
+				for (const e of entries) this.#readdirAddChild(e, children);
+				this.#readdirSuccess(children);
+			}
+			this.#callOnReaddirCB(children.slice(0, children.provisional));
+			return;
+		});
+	}
+	#asyncReaddirInFlight;
+	/**
+	* Return an array of known child entries.
+	*
+	* If the Path cannot or does not contain any children, then an empty array
+	* is returned.
+	*
+	* Results are cached, and thus may be out of date if the filesystem is
+	* mutated.
+	*/
+	async readdir() {
+		if (!this.canReaddir()) return [];
+		const children = this.children();
+		if (this.calledReaddir()) return children.slice(0, children.provisional);
+		const fullpath = this.fullpath();
+		if (this.#asyncReaddirInFlight) await this.#asyncReaddirInFlight;
+		else {
+			/* c8 ignore start */
+			let resolve$2 = () => {};
+			/* c8 ignore stop */
+			this.#asyncReaddirInFlight = new Promise((res) => resolve$2 = res);
+			try {
+				for (const e of await this.#fs.promises.readdir(fullpath, { withFileTypes: true })) this.#readdirAddChild(e, children);
+				this.#readdirSuccess(children);
+			} catch (er) {
+				this.#readdirFail(er.code);
+				children.provisional = 0;
+			}
+			this.#asyncReaddirInFlight = void 0;
+			resolve$2();
+		}
+		return children.slice(0, children.provisional);
+	}
+	/**
+	* synchronous {@link PathBase.readdir}
+	*/
+	readdirSync() {
+		if (!this.canReaddir()) return [];
+		const children = this.children();
+		if (this.calledReaddir()) return children.slice(0, children.provisional);
+		const fullpath = this.fullpath();
+		try {
+			for (const e of this.#fs.readdirSync(fullpath, { withFileTypes: true })) this.#readdirAddChild(e, children);
+			this.#readdirSuccess(children);
+		} catch (er) {
+			this.#readdirFail(er.code);
+			children.provisional = 0;
+		}
+		return children.slice(0, children.provisional);
+	}
+	canReaddir() {
+		if (this.#type & ENOCHILD) return false;
+		const ifmt = IFMT & this.#type;
+		/* c8 ignore start */
+		if (!(ifmt === UNKNOWN || ifmt === IFDIR || ifmt === IFLNK)) return false;
+		/* c8 ignore stop */
+		return true;
+	}
+	shouldWalk(dirs, walkFilter) {
+		return (this.#type & IFDIR) === IFDIR && !(this.#type & ENOCHILD) && !dirs.has(this) && (!walkFilter || walkFilter(this));
+	}
+	/**
+	* Return the Path object corresponding to path as resolved
+	* by realpath(3).
+	*
+	* If the realpath call fails for any reason, `undefined` is returned.
+	*
+	* Result is cached, and thus may be outdated if the filesystem is mutated.
+	* On success, returns a Path object.
+	*/
+	async realpath() {
+		if (this.#realpath) return this.#realpath;
+		if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type) return void 0;
+		try {
+			const rp = await this.#fs.promises.realpath(this.fullpath());
+			return this.#realpath = this.resolve(rp);
+		} catch (_) {
+			this.#markENOREALPATH();
+		}
+	}
+	/**
+	* Synchronous {@link realpath}
+	*/
+	realpathSync() {
+		if (this.#realpath) return this.#realpath;
+		if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type) return void 0;
+		try {
+			const rp = this.#fs.realpathSync(this.fullpath());
+			return this.#realpath = this.resolve(rp);
+		} catch (_) {
+			this.#markENOREALPATH();
+		}
+	}
+	/**
+	* Internal method to mark this Path object as the scurry cwd,
+	* called by {@link PathScurry#chdir}
+	*
+	* @internal
+	*/
+	[setAsCwd](oldCwd) {
+		if (oldCwd === this) return;
+		oldCwd.isCWD = false;
+		this.isCWD = true;
+		const changed = new Set([]);
+		let rp = [];
+		let p = this;
+		while (p && p.parent) {
+			changed.add(p);
+			p.#relative = rp.join(this.sep);
+			p.#relativePosix = rp.join("/");
+			p = p.parent;
+			rp.push("..");
+		}
+		p = oldCwd;
+		while (p && p.parent && !changed.has(p)) {
+			p.#relative = void 0;
+			p.#relativePosix = void 0;
+			p = p.parent;
+		}
+	}
+};
+/**
+* Path class used on win32 systems
+*
+* Uses `'\\'` as the path separator for returned paths, either `'\\'` or `'/'`
+* as the path separator for parsing paths.
+*/
+var PathWin32 = class PathWin32 extends PathBase {
+	/**
+	* Separator for generating path strings.
+	*/
+	sep = "\\";
+	/**
+	* Separator for parsing path strings.
+	*/
+	splitSep = eitherSep;
+	/**
+	* Do not create new Path objects directly.  They should always be accessed
+	* via the PathScurry class or other methods on the Path class.
+	*
+	* @internal
+	*/
+	constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+		super(name, type, root, roots, nocase, children, opts);
+	}
+	/**
+	* @internal
+	*/
+	newChild(name, type = UNKNOWN, opts = {}) {
+		return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+	}
+	/**
+	* @internal
+	*/
+	getRootString(path$4) {
+		return win32.parse(path$4).root;
+	}
+	/**
+	* @internal
+	*/
+	getRoot(rootPath) {
+		rootPath = uncToDrive(rootPath.toUpperCase());
+		if (rootPath === this.root.name) return this.root;
+		for (const [compare, root] of Object.entries(this.roots)) if (this.sameRoot(rootPath, compare)) return this.roots[rootPath] = root;
+		return this.roots[rootPath] = new PathScurryWin32(rootPath, this).root;
+	}
+	/**
+	* @internal
+	*/
+	sameRoot(rootPath, compare = this.root.name) {
+		rootPath = rootPath.toUpperCase().replace(/\//g, "\\").replace(uncDriveRegexp, "$1\\");
+		return rootPath === compare;
+	}
+};
+/**
+* Path class used on all posix systems.
+*
+* Uses `'/'` as the path separator.
+*/
+var PathPosix = class PathPosix extends PathBase {
+	/**
+	* separator for parsing path strings
+	*/
+	splitSep = "/";
+	/**
+	* separator for generating path strings
+	*/
+	sep = "/";
+	/**
+	* Do not create new Path objects directly.  They should always be accessed
+	* via the PathScurry class or other methods on the Path class.
+	*
+	* @internal
+	*/
+	constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+		super(name, type, root, roots, nocase, children, opts);
+	}
+	/**
+	* @internal
+	*/
+	getRootString(path$4) {
+		return path$4.startsWith("/") ? "/" : "";
+	}
+	/**
+	* @internal
+	*/
+	getRoot(_rootPath) {
+		return this.root;
+	}
+	/**
+	* @internal
+	*/
+	newChild(name, type = UNKNOWN, opts = {}) {
+		return new PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+	}
+};
+/**
+* The base class for all PathScurry classes, providing the interface for path
+* resolution and filesystem operations.
+*
+* Typically, you should *not* instantiate this class directly, but rather one
+* of the platform-specific classes, or the exported {@link PathScurry} which
+* defaults to the current platform.
+*/
+var PathScurryBase = class {
+	/**
+	* The root Path entry for the current working directory of this Scurry
+	*/
+	root;
+	/**
+	* The string path for the root of this Scurry's current working directory
+	*/
+	rootPath;
+	/**
+	* A collection of all roots encountered, referenced by rootPath
+	*/
+	roots;
+	/**
+	* The Path entry corresponding to this PathScurry's current working directory.
+	*/
+	cwd;
+	#resolveCache;
+	#resolvePosixCache;
+	#children;
+	/**
+	* Perform path comparisons case-insensitively.
+	*
+	* Defaults true on Darwin and Windows systems, false elsewhere.
+	*/
+	nocase;
+	#fs;
+	/**
+	* This class should not be instantiated directly.
+	*
+	* Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry
+	*
+	* @internal
+	*/
+	constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs$1 = defaultFS } = {}) {
+		this.#fs = fsFromOption(fs$1);
+		if (cwd instanceof URL || cwd.startsWith("file://")) cwd = fileURLToPath$1(cwd);
+		const cwdPath = pathImpl.resolve(cwd);
+		this.roots = Object.create(null);
+		this.rootPath = this.parseRootPath(cwdPath);
+		this.#resolveCache = new ResolveCache();
+		this.#resolvePosixCache = new ResolveCache();
+		this.#children = new ChildrenCache(childrenCacheSize);
+		const split = cwdPath.substring(this.rootPath.length).split(sep);
+		if (split.length === 1 && !split[0]) split.pop();
+		/* c8 ignore start */
+		if (nocase === void 0) throw new TypeError("must provide nocase setting to PathScurryBase ctor");
+		/* c8 ignore stop */
+		this.nocase = nocase;
+		this.root = this.newRoot(this.#fs);
+		this.roots[this.rootPath] = this.root;
+		let prev = this.root;
+		let len = split.length - 1;
+		const joinSep = pathImpl.sep;
+		let abs = this.rootPath;
+		let sawFirst = false;
+		for (const part of split) {
+			const l = len--;
+			prev = prev.child(part, {
+				relative: new Array(l).fill("..").join(joinSep),
+				relativePosix: new Array(l).fill("..").join("/"),
+				fullpath: abs += (sawFirst ? "" : joinSep) + part
+			});
+			sawFirst = true;
+		}
+		this.cwd = prev;
+	}
+	/**
+	* Get the depth of a provided path, string, or the cwd
+	*/
+	depth(path$4 = this.cwd) {
+		if (typeof path$4 === "string") path$4 = this.cwd.resolve(path$4);
+		return path$4.depth();
+	}
+	/**
+	* Return the cache of child entries.  Exposed so subclasses can create
+	* child Path objects in a platform-specific way.
+	*
+	* @internal
+	*/
+	childrenCache() {
+		return this.#children;
+	}
+	/**
+	* Resolve one or more path strings to a resolved string
+	*
+	* Same interface as require('path').resolve.
+	*
+	* Much faster than path.resolve() when called multiple times for the same
+	* path, because the resolved Path objects are cached.  Much slower
+	* otherwise.
+	*/
+	resolve(...paths) {
+		let r = "";
+		for (let i = paths.length - 1; i >= 0; i--) {
+			const p = paths[i];
+			if (!p || p === ".") continue;
+			r = r ? `${p}/${r}` : p;
+			if (this.isAbsolute(p)) break;
+		}
+		const cached = this.#resolveCache.get(r);
+		if (cached !== void 0) return cached;
+		const result = this.cwd.resolve(r).fullpath();
+		this.#resolveCache.set(r, result);
+		return result;
+	}
+	/**
+	* Resolve one or more path strings to a resolved string, returning
+	* the posix path.  Identical to .resolve() on posix systems, but on
+	* windows will return a forward-slash separated UNC path.
+	*
+	* Same interface as require('path').resolve.
+	*
+	* Much faster than path.resolve() when called multiple times for the same
+	* path, because the resolved Path objects are cached.  Much slower
+	* otherwise.
+	*/
+	resolvePosix(...paths) {
+		let r = "";
+		for (let i = paths.length - 1; i >= 0; i--) {
+			const p = paths[i];
+			if (!p || p === ".") continue;
+			r = r ? `${p}/${r}` : p;
+			if (this.isAbsolute(p)) break;
+		}
+		const cached = this.#resolvePosixCache.get(r);
+		if (cached !== void 0) return cached;
+		const result = this.cwd.resolve(r).fullpathPosix();
+		this.#resolvePosixCache.set(r, result);
+		return result;
+	}
+	/**
+	* find the relative path from the cwd to the supplied path string or entry
+	*/
+	relative(entry = this.cwd) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		return entry.relative();
+	}
+	/**
+	* find the relative path from the cwd to the supplied path string or
+	* entry, using / as the path delimiter, even on Windows.
+	*/
+	relativePosix(entry = this.cwd) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		return entry.relativePosix();
+	}
+	/**
+	* Return the basename for the provided string or Path object
+	*/
+	basename(entry = this.cwd) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		return entry.name;
+	}
+	/**
+	* Return the dirname for the provided string or Path object
+	*/
+	dirname(entry = this.cwd) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		return (entry.parent || entry).fullpath();
+	}
+	async readdir(entry = this.cwd, opts = { withFileTypes: true }) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			opts = entry;
+			entry = this.cwd;
+		}
+		const { withFileTypes } = opts;
+		if (!entry.canReaddir()) return [];
+		else {
+			const p = await entry.readdir();
+			return withFileTypes ? p : p.map((e) => e.name);
+		}
+	}
+	readdirSync(entry = this.cwd, opts = { withFileTypes: true }) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			opts = entry;
+			entry = this.cwd;
+		}
+		const { withFileTypes = true } = opts;
+		if (!entry.canReaddir()) return [];
+		else if (withFileTypes) return entry.readdirSync();
+		else return entry.readdirSync().map((e) => e.name);
+	}
+	/**
+	* Call lstat() on the string or Path object, and update all known
+	* information that can be determined.
+	*
+	* Note that unlike `fs.lstat()`, the returned value does not contain some
+	* information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
+	* information is required, you will need to call `fs.lstat` yourself.
+	*
+	* If the Path refers to a nonexistent file, or if the lstat call fails for
+	* any reason, `undefined` is returned.  Otherwise the updated Path object is
+	* returned.
+	*
+	* Results are cached, and thus may be out of date if the filesystem is
+	* mutated.
+	*/
+	async lstat(entry = this.cwd) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		return entry.lstat();
+	}
+	/**
+	* synchronous {@link PathScurryBase.lstat}
+	*/
+	lstatSync(entry = this.cwd) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		return entry.lstatSync();
+	}
+	async readlink(entry = this.cwd, { withFileTypes } = { withFileTypes: false }) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			withFileTypes = entry.withFileTypes;
+			entry = this.cwd;
+		}
+		const e = await entry.readlink();
+		return withFileTypes ? e : e?.fullpath();
+	}
+	readlinkSync(entry = this.cwd, { withFileTypes } = { withFileTypes: false }) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			withFileTypes = entry.withFileTypes;
+			entry = this.cwd;
+		}
+		const e = entry.readlinkSync();
+		return withFileTypes ? e : e?.fullpath();
+	}
+	async realpath(entry = this.cwd, { withFileTypes } = { withFileTypes: false }) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			withFileTypes = entry.withFileTypes;
+			entry = this.cwd;
+		}
+		const e = await entry.realpath();
+		return withFileTypes ? e : e?.fullpath();
+	}
+	realpathSync(entry = this.cwd, { withFileTypes } = { withFileTypes: false }) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			withFileTypes = entry.withFileTypes;
+			entry = this.cwd;
+		}
+		const e = entry.realpathSync();
+		return withFileTypes ? e : e?.fullpath();
+	}
+	async walk(entry = this.cwd, opts = {}) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			opts = entry;
+			entry = this.cwd;
+		}
+		const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+		const results = [];
+		if (!filter || filter(entry)) results.push(withFileTypes ? entry : entry.fullpath());
+		const dirs = new Set();
+		const walk = (dir, cb) => {
+			dirs.add(dir);
+			dir.readdirCB((er, entries) => {
+				/* c8 ignore start */
+				if (er) return cb(er);
+				/* c8 ignore stop */
+				let len = entries.length;
+				if (!len) return cb();
+				const next = () => {
+					if (--len === 0) cb();
+				};
+				for (const e of entries) {
+					if (!filter || filter(e)) results.push(withFileTypes ? e : e.fullpath());
+					if (follow && e.isSymbolicLink()) e.realpath().then((r) => r?.isUnknown() ? r.lstat() : r).then((r) => r?.shouldWalk(dirs, walkFilter) ? walk(r, next) : next());
+					else if (e.shouldWalk(dirs, walkFilter)) walk(e, next);
+					else next();
+				}
+			}, true);
+		};
+		const start = entry;
+		return new Promise((res, rej) => {
+			walk(start, (er) => {
+				/* c8 ignore start */
+				if (er) return rej(er);
+				/* c8 ignore stop */
+				res(results);
+			});
+		});
+	}
+	walkSync(entry = this.cwd, opts = {}) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			opts = entry;
+			entry = this.cwd;
+		}
+		const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+		const results = [];
+		if (!filter || filter(entry)) results.push(withFileTypes ? entry : entry.fullpath());
+		const dirs = new Set([entry]);
+		for (const dir of dirs) {
+			const entries = dir.readdirSync();
+			for (const e of entries) {
+				if (!filter || filter(e)) results.push(withFileTypes ? e : e.fullpath());
+				let r = e;
+				if (e.isSymbolicLink()) {
+					if (!(follow && (r = e.realpathSync()))) continue;
+					if (r.isUnknown()) r.lstatSync();
+				}
+				if (r.shouldWalk(dirs, walkFilter)) dirs.add(r);
+			}
+		}
+		return results;
+	}
+	/**
+	* Support for `for await`
+	*
+	* Alias for {@link PathScurryBase.iterate}
+	*
+	* Note: As of Node 19, this is very slow, compared to other methods of
+	* walking.  Consider using {@link PathScurryBase.stream} if memory overhead
+	* and backpressure are concerns, or {@link PathScurryBase.walk} if not.
+	*/
+	[Symbol.asyncIterator]() {
+		return this.iterate();
+	}
+	iterate(entry = this.cwd, options = {}) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			options = entry;
+			entry = this.cwd;
+		}
+		return this.stream(entry, options)[Symbol.asyncIterator]();
+	}
+	/**
+	* Iterating over a PathScurry performs a synchronous walk.
+	*
+	* Alias for {@link PathScurryBase.iterateSync}
+	*/
+	[Symbol.iterator]() {
+		return this.iterateSync();
+	}
+	*iterateSync(entry = this.cwd, opts = {}) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			opts = entry;
+			entry = this.cwd;
+		}
+		const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+		if (!filter || filter(entry)) yield withFileTypes ? entry : entry.fullpath();
+		const dirs = new Set([entry]);
+		for (const dir of dirs) {
+			const entries = dir.readdirSync();
+			for (const e of entries) {
+				if (!filter || filter(e)) yield withFileTypes ? e : e.fullpath();
+				let r = e;
+				if (e.isSymbolicLink()) {
+					if (!(follow && (r = e.realpathSync()))) continue;
+					if (r.isUnknown()) r.lstatSync();
+				}
+				if (r.shouldWalk(dirs, walkFilter)) dirs.add(r);
+			}
+		}
+	}
+	stream(entry = this.cwd, opts = {}) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			opts = entry;
+			entry = this.cwd;
+		}
+		const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+		const results = new Minipass({ objectMode: true });
+		if (!filter || filter(entry)) results.write(withFileTypes ? entry : entry.fullpath());
+		const dirs = new Set();
+		const queue = [entry];
+		let processing = 0;
+		const process$1 = () => {
+			let paused = false;
+			while (!paused) {
+				const dir = queue.shift();
+				if (!dir) {
+					if (processing === 0) results.end();
+					return;
+				}
+				processing++;
+				dirs.add(dir);
+				const onReaddir = (er, entries, didRealpaths = false) => {
+					/* c8 ignore start */
+					if (er) return results.emit("error", er);
+					/* c8 ignore stop */
+					if (follow && !didRealpaths) {
+						const promises$1 = [];
+						for (const e of entries) if (e.isSymbolicLink()) promises$1.push(e.realpath().then((r) => r?.isUnknown() ? r.lstat() : r));
+						if (promises$1.length) {
+							Promise.all(promises$1).then(() => onReaddir(null, entries, true));
+							return;
+						}
+					}
+					for (const e of entries) if (e && (!filter || filter(e))) {
+						if (!results.write(withFileTypes ? e : e.fullpath())) paused = true;
+					}
+					processing--;
+					for (const e of entries) {
+						const r = e.realpathCached() || e;
+						if (r.shouldWalk(dirs, walkFilter)) queue.push(r);
+					}
+					if (paused && !results.flowing) results.once("drain", process$1);
+					else if (!sync$1) process$1();
+				};
+				let sync$1 = true;
+				dir.readdirCB(onReaddir, true);
+				sync$1 = false;
+			}
+		};
+		process$1();
+		return results;
+	}
+	streamSync(entry = this.cwd, opts = {}) {
+		if (typeof entry === "string") entry = this.cwd.resolve(entry);
+		else if (!(entry instanceof PathBase)) {
+			opts = entry;
+			entry = this.cwd;
+		}
+		const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+		const results = new Minipass({ objectMode: true });
+		const dirs = new Set();
+		if (!filter || filter(entry)) results.write(withFileTypes ? entry : entry.fullpath());
+		const queue = [entry];
+		let processing = 0;
+		const process$1 = () => {
+			let paused = false;
+			while (!paused) {
+				const dir = queue.shift();
+				if (!dir) {
+					if (processing === 0) results.end();
+					return;
+				}
+				processing++;
+				dirs.add(dir);
+				const entries = dir.readdirSync();
+				for (const e of entries) if (!filter || filter(e)) {
+					if (!results.write(withFileTypes ? e : e.fullpath())) paused = true;
+				}
+				processing--;
+				for (const e of entries) {
+					let r = e;
+					if (e.isSymbolicLink()) {
+						if (!(follow && (r = e.realpathSync()))) continue;
+						if (r.isUnknown()) r.lstatSync();
+					}
+					if (r.shouldWalk(dirs, walkFilter)) queue.push(r);
+				}
+			}
+			if (paused && !results.flowing) results.once("drain", process$1);
+		};
+		process$1();
+		return results;
+	}
+	chdir(path$4 = this.cwd) {
+		const oldCwd = this.cwd;
+		this.cwd = typeof path$4 === "string" ? this.cwd.resolve(path$4) : path$4;
+		this.cwd[setAsCwd](oldCwd);
+	}
+};
+/**
+* Windows implementation of {@link PathScurryBase}
+*
+* Defaults to case insensitve, uses `'\\'` to generate path strings.  Uses
+* {@link PathWin32} for Path objects.
+*/
+var PathScurryWin32 = class extends PathScurryBase {
+	/**
+	* separator for generating path strings
+	*/
+	sep = "\\";
+	constructor(cwd = process.cwd(), opts = {}) {
+		const { nocase = true } = opts;
+		super(cwd, win32, "\\", {
+			...opts,
+			nocase
+		});
+		this.nocase = nocase;
+		for (let p = this.cwd; p; p = p.parent) p.nocase = this.nocase;
+	}
+	/**
+	* @internal
+	*/
+	parseRootPath(dir) {
+		return win32.parse(dir).root.toUpperCase();
+	}
+	/**
+	* @internal
+	*/
+	newRoot(fs$1) {
+		return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs$1 });
+	}
+	/**
+	* Return true if the provided path string is an absolute path
+	*/
+	isAbsolute(p) {
+		return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
+	}
+};
+/**
+* {@link PathScurryBase} implementation for all posix systems other than Darwin.
+*
+* Defaults to case-sensitive matching, uses `'/'` to generate path strings.
+*
+* Uses {@link PathPosix} for Path objects.
+*/
+var PathScurryPosix = class extends PathScurryBase {
+	/**
+	* separator for generating path strings
+	*/
+	sep = "/";
+	constructor(cwd = process.cwd(), opts = {}) {
+		const { nocase = false } = opts;
+		super(cwd, posix, "/", {
+			...opts,
+			nocase
+		});
+		this.nocase = nocase;
+	}
+	/**
+	* @internal
+	*/
+	parseRootPath(_dir) {
+		return "/";
+	}
+	/**
+	* @internal
+	*/
+	newRoot(fs$1) {
+		return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs$1 });
+	}
+	/**
+	* Return true if the provided path string is an absolute path
+	*/
+	isAbsolute(p) {
+		return p.startsWith("/");
+	}
+};
+/**
+* {@link PathScurryBase} implementation for Darwin (macOS) systems.
+*
+* Defaults to case-insensitive matching, uses `'/'` for generating path
+* strings.
+*
+* Uses {@link PathPosix} for Path objects.
+*/
+var PathScurryDarwin = class extends PathScurryPosix {
+	constructor(cwd = process.cwd(), opts = {}) {
+		const { nocase = true } = opts;
+		super(cwd, {
+			...opts,
+			nocase
+		});
+	}
+};
+/**
+* Default {@link PathBase} implementation for the current platform.
+*
+* {@link PathWin32} on Windows systems, {@link PathPosix} on all others.
+*/
+const Path = process.platform === "win32" ? PathWin32 : PathPosix;
+/**
+* Default {@link PathScurryBase} implementation for the current platform.
+*
+* {@link PathScurryWin32} on Windows systems, {@link PathScurryDarwin} on
+* Darwin (macOS) systems, {@link PathScurryPosix} on all others.
+*/
+const PathScurry = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
+
+//#endregion
+//#region node_modules/glob/dist/esm/pattern.js
+const isPatternList = (pl) => pl.length >= 1;
+const isGlobList = (gl) => gl.length >= 1;
+/**
+* An immutable-ish view on an array of glob parts and their parsed
+* results
+*/
+var Pattern = class Pattern {
+	#patternList;
+	#globList;
+	#index;
+	length;
+	#platform;
+	#rest;
+	#globString;
+	#isDrive;
+	#isUNC;
+	#isAbsolute;
+	#followGlobstar = true;
+	constructor(patternList, globList, index, platform) {
+		if (!isPatternList(patternList)) throw new TypeError("empty pattern list");
+		if (!isGlobList(globList)) throw new TypeError("empty glob list");
+		if (globList.length !== patternList.length) throw new TypeError("mismatched pattern list and glob list lengths");
+		this.length = patternList.length;
+		if (index < 0 || index >= this.length) throw new TypeError("index out of range");
+		this.#patternList = patternList;
+		this.#globList = globList;
+		this.#index = index;
+		this.#platform = platform;
+		if (this.#index === 0) {
+			if (this.isUNC()) {
+				const [p0, p1, p2, p3, ...prest] = this.#patternList;
+				const [g0, g1, g2, g3, ...grest] = this.#globList;
+				if (prest[0] === "") {
+					prest.shift();
+					grest.shift();
+				}
+				const p = [
+					p0,
+					p1,
+					p2,
+					p3,
+					""
+				].join("/");
+				const g = [
+					g0,
+					g1,
+					g2,
+					g3,
+					""
+				].join("/");
+				this.#patternList = [p, ...prest];
+				this.#globList = [g, ...grest];
+				this.length = this.#patternList.length;
+			} else if (this.isDrive() || this.isAbsolute()) {
+				const [p1, ...prest] = this.#patternList;
+				const [g1, ...grest] = this.#globList;
+				if (prest[0] === "") {
+					prest.shift();
+					grest.shift();
+				}
+				const p = p1 + "/";
+				const g = g1 + "/";
+				this.#patternList = [p, ...prest];
+				this.#globList = [g, ...grest];
+				this.length = this.#patternList.length;
+			}
+		}
+	}
+	/**
+	* The first entry in the parsed list of patterns
+	*/
+	pattern() {
+		return this.#patternList[this.#index];
+	}
+	/**
+	* true of if pattern() returns a string
+	*/
+	isString() {
+		return typeof this.#patternList[this.#index] === "string";
+	}
+	/**
+	* true of if pattern() returns GLOBSTAR
+	*/
+	isGlobstar() {
+		return this.#patternList[this.#index] === GLOBSTAR;
+	}
+	/**
+	* true if pattern() returns a regexp
+	*/
+	isRegExp() {
+		return this.#patternList[this.#index] instanceof RegExp;
+	}
+	/**
+	* The /-joined set of glob parts that make up this pattern
+	*/
+	globString() {
+		return this.#globString = this.#globString || (this.#index === 0 ? this.isAbsolute() ? this.#globList[0] + this.#globList.slice(1).join("/") : this.#globList.join("/") : this.#globList.slice(this.#index).join("/"));
+	}
+	/**
+	* true if there are more pattern parts after this one
+	*/
+	hasMore() {
+		return this.length > this.#index + 1;
+	}
+	/**
+	* The rest of the pattern after this part, or null if this is the end
+	*/
+	rest() {
+		if (this.#rest !== void 0) return this.#rest;
+		if (!this.hasMore()) return this.#rest = null;
+		this.#rest = new Pattern(this.#patternList, this.#globList, this.#index + 1, this.#platform);
+		this.#rest.#isAbsolute = this.#isAbsolute;
+		this.#rest.#isUNC = this.#isUNC;
+		this.#rest.#isDrive = this.#isDrive;
+		return this.#rest;
+	}
+	/**
+	* true if the pattern represents a //unc/path/ on windows
+	*/
+	isUNC() {
+		const pl = this.#patternList;
+		return this.#isUNC !== void 0 ? this.#isUNC : this.#isUNC = this.#platform === "win32" && this.#index === 0 && pl[0] === "" && pl[1] === "" && typeof pl[2] === "string" && !!pl[2] && typeof pl[3] === "string" && !!pl[3];
+	}
+	/**
+	* True if the pattern starts with a drive letter on Windows
+	*/
+	isDrive() {
+		const pl = this.#patternList;
+		return this.#isDrive !== void 0 ? this.#isDrive : this.#isDrive = this.#platform === "win32" && this.#index === 0 && this.length > 1 && typeof pl[0] === "string" && /^[a-z]:$/i.test(pl[0]);
+	}
+	/**
+	* True if the pattern is rooted on an absolute path
+	*/
+	isAbsolute() {
+		const pl = this.#patternList;
+		return this.#isAbsolute !== void 0 ? this.#isAbsolute : this.#isAbsolute = pl[0] === "" && pl.length > 1 || this.isDrive() || this.isUNC();
+	}
+	/**
+	* consume the root of the pattern, and return it
+	*/
+	root() {
+		const p = this.#patternList[0];
+		return typeof p === "string" && this.isAbsolute() && this.#index === 0 ? p : "";
+	}
+	/**
+	* Check to see if the current globstar pattern is allowed to follow
+	* a symbolic link.
+	*/
+	checkFollowGlobstar() {
+		return !(this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar);
+	}
+	/**
+	* Mark that the current globstar pattern is following a symbolic link
+	*/
+	markFollowGlobstar() {
+		if (this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar) return false;
+		this.#followGlobstar = false;
+		return true;
+	}
+};
+
+//#endregion
+//#region node_modules/glob/dist/esm/ignore.js
+const defaultPlatform$1 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+/**
+* Class used to process ignored patterns
+*/
+var Ignore = class {
+	relative;
+	relativeChildren;
+	absolute;
+	absoluteChildren;
+	platform;
+	mmopts;
+	constructor(ignored, { nobrace, nocase, noext, noglobstar, platform = defaultPlatform$1 }) {
+		this.relative = [];
+		this.absolute = [];
+		this.relativeChildren = [];
+		this.absoluteChildren = [];
+		this.platform = platform;
+		this.mmopts = {
+			dot: true,
+			nobrace,
+			nocase,
+			noext,
+			noglobstar,
+			optimizationLevel: 2,
+			platform,
+			nocomment: true,
+			nonegate: true
+		};
+		for (const ign of ignored) this.add(ign);
+	}
+	add(ign) {
+		const mm = new Minimatch(ign, this.mmopts);
+		for (let i = 0; i < mm.set.length; i++) {
+			const parsed = mm.set[i];
+			const globParts = mm.globParts[i];
+			/* c8 ignore start */
+			if (!parsed || !globParts) throw new Error("invalid pattern object");
+			while (parsed[0] === "." && globParts[0] === ".") {
+				parsed.shift();
+				globParts.shift();
+			}
+			/* c8 ignore stop */
+			const p = new Pattern(parsed, globParts, 0, this.platform);
+			const m = new Minimatch(p.globString(), this.mmopts);
+			const children = globParts[globParts.length - 1] === "**";
+			const absolute = p.isAbsolute();
+			if (absolute) this.absolute.push(m);
+			else this.relative.push(m);
+			if (children) if (absolute) this.absoluteChildren.push(m);
+			else this.relativeChildren.push(m);
+		}
+	}
+	ignored(p) {
+		const fullpath = p.fullpath();
+		const fullpaths = `${fullpath}/`;
+		const relative$1 = p.relative() || ".";
+		const relatives = `${relative$1}/`;
+		for (const m of this.relative) if (m.match(relative$1) || m.match(relatives)) return true;
+		for (const m of this.absolute) if (m.match(fullpath) || m.match(fullpaths)) return true;
+		return false;
+	}
+	childrenIgnored(p) {
+		const fullpath = p.fullpath() + "/";
+		const relative$1 = (p.relative() || ".") + "/";
+		for (const m of this.relativeChildren) if (m.match(relative$1)) return true;
+		for (const m of this.absoluteChildren) if (m.match(fullpath)) return true;
+		return false;
+	}
+};
+
+//#endregion
+//#region node_modules/glob/dist/esm/processor.js
+/**
+* A cache of which patterns have been processed for a given Path
+*/
+var HasWalkedCache = class HasWalkedCache {
+	store;
+	constructor(store = new Map()) {
+		this.store = store;
+	}
+	copy() {
+		return new HasWalkedCache(new Map(this.store));
+	}
+	hasWalked(target, pattern) {
+		return this.store.get(target.fullpath())?.has(pattern.globString());
+	}
+	storeWalked(target, pattern) {
+		const fullpath = target.fullpath();
+		const cached = this.store.get(fullpath);
+		if (cached) cached.add(pattern.globString());
+		else this.store.set(fullpath, new Set([pattern.globString()]));
+	}
+};
+/**
+* A record of which paths have been matched in a given walk step,
+* and whether they only are considered a match if they are a directory,
+* and whether their absolute or relative path should be returned.
+*/
+var MatchRecord = class {
+	store = new Map();
+	add(target, absolute, ifDir) {
+		const n = (absolute ? 2 : 0) | (ifDir ? 1 : 0);
+		const current = this.store.get(target);
+		this.store.set(target, current === void 0 ? n : n & current);
+	}
+	entries() {
+		return [...this.store.entries()].map(([path$4, n]) => [
+			path$4,
+			!!(n & 2),
+			!!(n & 1)
+		]);
+	}
+};
+/**
+* A collection of patterns that must be processed in a subsequent step
+* for a given path.
+*/
+var SubWalks = class {
+	store = new Map();
+	add(target, pattern) {
+		if (!target.canReaddir()) return;
+		const subs = this.store.get(target);
+		if (subs) {
+			if (!subs.find((p) => p.globString() === pattern.globString())) subs.push(pattern);
+		} else this.store.set(target, [pattern]);
+	}
+	get(target) {
+		const subs = this.store.get(target);
+		/* c8 ignore start */
+		if (!subs) throw new Error("attempting to walk unknown path");
+		/* c8 ignore stop */
+		return subs;
+	}
+	entries() {
+		return this.keys().map((k) => [k, this.store.get(k)]);
+	}
+	keys() {
+		return [...this.store.keys()].filter((t) => t.canReaddir());
+	}
+};
+/**
+* The class that processes patterns for a given path.
+*
+* Handles child entry filtering, and determining whether a path's
+* directory contents must be read.
+*/
+var Processor = class Processor {
+	hasWalkedCache;
+	matches = new MatchRecord();
+	subwalks = new SubWalks();
+	patterns;
+	follow;
+	dot;
+	opts;
+	constructor(opts, hasWalkedCache) {
+		this.opts = opts;
+		this.follow = !!opts.follow;
+		this.dot = !!opts.dot;
+		this.hasWalkedCache = hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache();
+	}
+	processPatterns(target, patterns) {
+		this.patterns = patterns;
+		const processingSet = patterns.map((p) => [target, p]);
+		for (let [t, pattern] of processingSet) {
+			this.hasWalkedCache.storeWalked(t, pattern);
+			const root = pattern.root();
+			const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
+			if (root) {
+				t = t.resolve(root === "/" && this.opts.root !== void 0 ? this.opts.root : root);
+				const rest$1 = pattern.rest();
+				if (!rest$1) {
+					this.matches.add(t, true, false);
+					continue;
+				} else pattern = rest$1;
+			}
+			if (t.isENOENT()) continue;
+			let p;
+			let rest;
+			let changed = false;
+			while (typeof (p = pattern.pattern()) === "string" && (rest = pattern.rest())) {
+				const c = t.resolve(p);
+				t = c;
+				pattern = rest;
+				changed = true;
+			}
+			p = pattern.pattern();
+			rest = pattern.rest();
+			if (changed) {
+				if (this.hasWalkedCache.hasWalked(t, pattern)) continue;
+				this.hasWalkedCache.storeWalked(t, pattern);
+			}
+			if (typeof p === "string") {
+				const ifDir = p === ".." || p === "" || p === ".";
+				this.matches.add(t.resolve(p), absolute, ifDir);
+				continue;
+			} else if (p === GLOBSTAR) {
+				if (!t.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) this.subwalks.add(t, pattern);
+				const rp = rest?.pattern();
+				const rrest = rest?.rest();
+				if (!rest || (rp === "" || rp === ".") && !rrest) this.matches.add(t, absolute, rp === "" || rp === ".");
+				else if (rp === "..") {
+					/* c8 ignore start */
+					const tp = t.parent || t;
+					/* c8 ignore stop */
+					if (!rrest) this.matches.add(tp, absolute, true);
+					else if (!this.hasWalkedCache.hasWalked(tp, rrest)) this.subwalks.add(tp, rrest);
+				}
+			} else if (p instanceof RegExp) this.subwalks.add(t, pattern);
+		}
+		return this;
+	}
+	subwalkTargets() {
+		return this.subwalks.keys();
+	}
+	child() {
+		return new Processor(this.opts, this.hasWalkedCache);
+	}
+	filterEntries(parent, entries) {
+		const patterns = this.subwalks.get(parent);
+		const results = this.child();
+		for (const e of entries) for (const pattern of patterns) {
+			const absolute = pattern.isAbsolute();
+			const p = pattern.pattern();
+			const rest = pattern.rest();
+			if (p === GLOBSTAR) results.testGlobstar(e, pattern, rest, absolute);
+			else if (p instanceof RegExp) results.testRegExp(e, p, rest, absolute);
+			else results.testString(e, p, rest, absolute);
+		}
+		return results;
+	}
+	testGlobstar(e, pattern, rest, absolute) {
+		if (this.dot || !e.name.startsWith(".")) {
+			if (!pattern.hasMore()) this.matches.add(e, absolute, false);
+			if (e.canReaddir()) {
+				if (this.follow || !e.isSymbolicLink()) this.subwalks.add(e, pattern);
+				else if (e.isSymbolicLink()) {
+					if (rest && pattern.checkFollowGlobstar()) this.subwalks.add(e, rest);
+					else if (pattern.markFollowGlobstar()) this.subwalks.add(e, pattern);
+				}
+			}
+		}
+		if (rest) {
+			const rp = rest.pattern();
+			if (typeof rp === "string" && rp !== ".." && rp !== "" && rp !== ".") this.testString(e, rp, rest.rest(), absolute);
+			else if (rp === "..") {
+				/* c8 ignore start */
+				const ep = e.parent || e;
+				/* c8 ignore stop */
+				this.subwalks.add(ep, rest);
+			} else if (rp instanceof RegExp) this.testRegExp(e, rp, rest.rest(), absolute);
+		}
+	}
+	testRegExp(e, p, rest, absolute) {
+		if (!p.test(e.name)) return;
+		if (!rest) this.matches.add(e, absolute, false);
+		else this.subwalks.add(e, rest);
+	}
+	testString(e, p, rest, absolute) {
+		if (!e.isNamed(p)) return;
+		if (!rest) this.matches.add(e, absolute, false);
+		else this.subwalks.add(e, rest);
+	}
+};
+
+//#endregion
+//#region node_modules/glob/dist/esm/walker.js
+const makeIgnore = (ignore, opts) => typeof ignore === "string" ? new Ignore([ignore], opts) : Array.isArray(ignore) ? new Ignore(ignore, opts) : ignore;
+/**
+* basic walking utilities that all the glob walker types use
+*/
+var GlobUtil = class {
+	path;
+	patterns;
+	opts;
+	seen = new Set();
+	paused = false;
+	aborted = false;
+	#onResume = [];
+	#ignore;
+	#sep;
+	signal;
+	maxDepth;
+	includeChildMatches;
+	constructor(patterns, path$4, opts) {
+		this.patterns = patterns;
+		this.path = path$4;
+		this.opts = opts;
+		this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
+		this.includeChildMatches = opts.includeChildMatches !== false;
+		if (opts.ignore || !this.includeChildMatches) {
+			this.#ignore = makeIgnore(opts.ignore ?? [], opts);
+			if (!this.includeChildMatches && typeof this.#ignore.add !== "function") {
+				const m = "cannot ignore child matches, ignore lacks add() method.";
+				throw new Error(m);
+			}
+		}
+		/* c8 ignore start */
+		this.maxDepth = opts.maxDepth || Infinity;
+		/* c8 ignore stop */
+		if (opts.signal) {
+			this.signal = opts.signal;
+			this.signal.addEventListener("abort", () => {
+				this.#onResume.length = 0;
+			});
+		}
+	}
+	#ignored(path$4) {
+		return this.seen.has(path$4) || !!this.#ignore?.ignored?.(path$4);
+	}
+	#childrenIgnored(path$4) {
+		return !!this.#ignore?.childrenIgnored?.(path$4);
+	}
+	pause() {
+		this.paused = true;
+	}
+	resume() {
+		/* c8 ignore start */
+		if (this.signal?.aborted) return;
+		/* c8 ignore stop */
+		this.paused = false;
+		let fn = void 0;
+		while (!this.paused && (fn = this.#onResume.shift())) fn();
+	}
+	onResume(fn) {
+		if (this.signal?.aborted) return;
+		/* c8 ignore start */
+		if (!this.paused) fn();
+		else
+ /* c8 ignore stop */
+		this.#onResume.push(fn);
+	}
+	async matchCheck(e, ifDir) {
+		if (ifDir && this.opts.nodir) return void 0;
+		let rpc;
+		if (this.opts.realpath) {
+			rpc = e.realpathCached() || await e.realpath();
+			if (!rpc) return void 0;
+			e = rpc;
+		}
+		const needStat = e.isUnknown() || this.opts.stat;
+		const s = needStat ? await e.lstat() : e;
+		if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+			const target = await s.realpath();
+			/* c8 ignore start */
+			if (target && (target.isUnknown() || this.opts.stat)) await target.lstat();
+		}
+		return this.matchCheckTest(s, ifDir);
+	}
+	matchCheckTest(e, ifDir) {
+		return e && (this.maxDepth === Infinity || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !e.realpathCached()?.isDirectory()) && !this.#ignored(e) ? e : void 0;
+	}
+	matchCheckSync(e, ifDir) {
+		if (ifDir && this.opts.nodir) return void 0;
+		let rpc;
+		if (this.opts.realpath) {
+			rpc = e.realpathCached() || e.realpathSync();
+			if (!rpc) return void 0;
+			e = rpc;
+		}
+		const needStat = e.isUnknown() || this.opts.stat;
+		const s = needStat ? e.lstatSync() : e;
+		if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+			const target = s.realpathSync();
+			if (target && (target?.isUnknown() || this.opts.stat)) target.lstatSync();
+		}
+		return this.matchCheckTest(s, ifDir);
+	}
+	matchFinish(e, absolute) {
+		if (this.#ignored(e)) return;
+		if (!this.includeChildMatches && this.#ignore?.add) {
+			const ign = `${e.relativePosix()}/**`;
+			this.#ignore.add(ign);
+		}
+		const abs = this.opts.absolute === void 0 ? absolute : this.opts.absolute;
+		this.seen.add(e);
+		const mark = this.opts.mark && e.isDirectory() ? this.#sep : "";
+		if (this.opts.withFileTypes) this.matchEmit(e);
+		else if (abs) {
+			const abs$1 = this.opts.posix ? e.fullpathPosix() : e.fullpath();
+			this.matchEmit(abs$1 + mark);
+		} else {
+			const rel = this.opts.posix ? e.relativePosix() : e.relative();
+			const pre = this.opts.dotRelative && !rel.startsWith(".." + this.#sep) ? "." + this.#sep : "";
+			this.matchEmit(!rel ? "." + mark : pre + rel + mark);
+		}
+	}
+	async match(e, absolute, ifDir) {
+		const p = await this.matchCheck(e, ifDir);
+		if (p) this.matchFinish(p, absolute);
+	}
+	matchSync(e, absolute, ifDir) {
+		const p = this.matchCheckSync(e, ifDir);
+		if (p) this.matchFinish(p, absolute);
+	}
+	walkCB(target, patterns, cb) {
+		/* c8 ignore start */
+		if (this.signal?.aborted) cb();
+		/* c8 ignore stop */
+		this.walkCB2(target, patterns, new Processor(this.opts), cb);
+	}
+	walkCB2(target, patterns, processor, cb) {
+		if (this.#childrenIgnored(target)) return cb();
+		if (this.signal?.aborted) cb();
+		if (this.paused) {
+			this.onResume(() => this.walkCB2(target, patterns, processor, cb));
+			return;
+		}
+		processor.processPatterns(target, patterns);
+		let tasks = 1;
+		const next = () => {
+			if (--tasks === 0) cb();
+		};
+		for (const [m, absolute, ifDir] of processor.matches.entries()) {
+			if (this.#ignored(m)) continue;
+			tasks++;
+			this.match(m, absolute, ifDir).then(() => next());
+		}
+		for (const t of processor.subwalkTargets()) {
+			if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) continue;
+			tasks++;
+			const childrenCached = t.readdirCached();
+			if (t.calledReaddir()) this.walkCB3(t, childrenCached, processor, next);
+			else t.readdirCB((_, entries) => this.walkCB3(t, entries, processor, next), true);
+		}
+		next();
+	}
+	walkCB3(target, entries, processor, cb) {
+		processor = processor.filterEntries(target, entries);
+		let tasks = 1;
+		const next = () => {
+			if (--tasks === 0) cb();
+		};
+		for (const [m, absolute, ifDir] of processor.matches.entries()) {
+			if (this.#ignored(m)) continue;
+			tasks++;
+			this.match(m, absolute, ifDir).then(() => next());
+		}
+		for (const [target$1, patterns] of processor.subwalks.entries()) {
+			tasks++;
+			this.walkCB2(target$1, patterns, processor.child(), next);
+		}
+		next();
+	}
+	walkCBSync(target, patterns, cb) {
+		/* c8 ignore start */
+		if (this.signal?.aborted) cb();
+		/* c8 ignore stop */
+		this.walkCB2Sync(target, patterns, new Processor(this.opts), cb);
+	}
+	walkCB2Sync(target, patterns, processor, cb) {
+		if (this.#childrenIgnored(target)) return cb();
+		if (this.signal?.aborted) cb();
+		if (this.paused) {
+			this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
+			return;
+		}
+		processor.processPatterns(target, patterns);
+		let tasks = 1;
+		const next = () => {
+			if (--tasks === 0) cb();
+		};
+		for (const [m, absolute, ifDir] of processor.matches.entries()) {
+			if (this.#ignored(m)) continue;
+			this.matchSync(m, absolute, ifDir);
+		}
+		for (const t of processor.subwalkTargets()) {
+			if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) continue;
+			tasks++;
+			const children = t.readdirSync();
+			this.walkCB3Sync(t, children, processor, next);
+		}
+		next();
+	}
+	walkCB3Sync(target, entries, processor, cb) {
+		processor = processor.filterEntries(target, entries);
+		let tasks = 1;
+		const next = () => {
+			if (--tasks === 0) cb();
+		};
+		for (const [m, absolute, ifDir] of processor.matches.entries()) {
+			if (this.#ignored(m)) continue;
+			this.matchSync(m, absolute, ifDir);
+		}
+		for (const [target$1, patterns] of processor.subwalks.entries()) {
+			tasks++;
+			this.walkCB2Sync(target$1, patterns, processor.child(), next);
+		}
+		next();
+	}
+};
+var GlobWalker = class extends GlobUtil {
+	matches = new Set();
+	constructor(patterns, path$4, opts) {
+		super(patterns, path$4, opts);
+	}
+	matchEmit(e) {
+		this.matches.add(e);
+	}
+	async walk() {
+		if (this.signal?.aborted) throw this.signal.reason;
+		if (this.path.isUnknown()) await this.path.lstat();
+		await new Promise((res, rej) => {
+			this.walkCB(this.path, this.patterns, () => {
+				if (this.signal?.aborted) rej(this.signal.reason);
+				else res(this.matches);
+			});
+		});
+		return this.matches;
+	}
+	walkSync() {
+		if (this.signal?.aborted) throw this.signal.reason;
+		if (this.path.isUnknown()) this.path.lstatSync();
+		this.walkCBSync(this.path, this.patterns, () => {
+			if (this.signal?.aborted) throw this.signal.reason;
+		});
+		return this.matches;
+	}
+};
+var GlobStream = class extends GlobUtil {
+	results;
+	constructor(patterns, path$4, opts) {
+		super(patterns, path$4, opts);
+		this.results = new Minipass({
+			signal: this.signal,
+			objectMode: true
+		});
+		this.results.on("drain", () => this.resume());
+		this.results.on("resume", () => this.resume());
+	}
+	matchEmit(e) {
+		this.results.write(e);
+		if (!this.results.flowing) this.pause();
+	}
+	stream() {
+		const target = this.path;
+		if (target.isUnknown()) target.lstat().then(() => {
+			this.walkCB(target, this.patterns, () => this.results.end());
+		});
+		else this.walkCB(target, this.patterns, () => this.results.end());
+		return this.results;
+	}
+	streamSync() {
+		if (this.path.isUnknown()) this.path.lstatSync();
+		this.walkCBSync(this.path, this.patterns, () => this.results.end());
+		return this.results;
+	}
+};
+
+//#endregion
+//#region node_modules/glob/dist/esm/glob.js
+const defaultPlatform = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+/**
+* An object that can perform glob pattern traversals.
+*/
+var Glob = class {
+	absolute;
+	cwd;
+	root;
+	dot;
+	dotRelative;
+	follow;
+	ignore;
+	magicalBraces;
+	mark;
+	matchBase;
+	maxDepth;
+	nobrace;
+	nocase;
+	nodir;
+	noext;
+	noglobstar;
+	pattern;
+	platform;
+	realpath;
+	scurry;
+	stat;
+	signal;
+	windowsPathsNoEscape;
+	withFileTypes;
+	includeChildMatches;
+	/**
+	* The options provided to the constructor.
+	*/
+	opts;
+	/**
+	* An array of parsed immutable {@link Pattern} objects.
+	*/
+	patterns;
+	/**
+	* All options are stored as properties on the `Glob` object.
+	*
+	* See {@link GlobOptions} for full options descriptions.
+	*
+	* Note that a previous `Glob` object can be passed as the
+	* `GlobOptions` to another `Glob` instantiation to re-use settings
+	* and caches with a new pattern.
+	*
+	* Traversal functions can be called multiple times to run the walk
+	* again.
+	*/
+	constructor(pattern, opts) {
+		/* c8 ignore start */
+		if (!opts) throw new TypeError("glob options required");
+		/* c8 ignore stop */
+		this.withFileTypes = !!opts.withFileTypes;
+		this.signal = opts.signal;
+		this.follow = !!opts.follow;
+		this.dot = !!opts.dot;
+		this.dotRelative = !!opts.dotRelative;
+		this.nodir = !!opts.nodir;
+		this.mark = !!opts.mark;
+		if (!opts.cwd) this.cwd = "";
+		else if (opts.cwd instanceof URL || opts.cwd.startsWith("file://")) opts.cwd = fileURLToPath$1(opts.cwd);
+		this.cwd = opts.cwd || "";
+		this.root = opts.root;
+		this.magicalBraces = !!opts.magicalBraces;
+		this.nobrace = !!opts.nobrace;
+		this.noext = !!opts.noext;
+		this.realpath = !!opts.realpath;
+		this.absolute = opts.absolute;
+		this.includeChildMatches = opts.includeChildMatches !== false;
+		this.noglobstar = !!opts.noglobstar;
+		this.matchBase = !!opts.matchBase;
+		this.maxDepth = typeof opts.maxDepth === "number" ? opts.maxDepth : Infinity;
+		this.stat = !!opts.stat;
+		this.ignore = opts.ignore;
+		if (this.withFileTypes && this.absolute !== void 0) throw new Error("cannot set absolute and withFileTypes:true");
+		if (typeof pattern === "string") pattern = [pattern];
+		this.windowsPathsNoEscape = !!opts.windowsPathsNoEscape || opts.allowWindowsEscape === false;
+		if (this.windowsPathsNoEscape) pattern = pattern.map((p) => p.replace(/\\/g, "/"));
+		if (this.matchBase) {
+			if (opts.noglobstar) throw new TypeError("base matching requires globstar");
+			pattern = pattern.map((p) => p.includes("/") ? p : `./**/${p}`);
+		}
+		this.pattern = pattern;
+		this.platform = opts.platform || defaultPlatform;
+		this.opts = {
+			...opts,
+			platform: this.platform
+		};
+		if (opts.scurry) {
+			this.scurry = opts.scurry;
+			if (opts.nocase !== void 0 && opts.nocase !== opts.scurry.nocase) throw new Error("nocase option contradicts provided scurry option");
+		} else {
+			const Scurry = opts.platform === "win32" ? PathScurryWin32 : opts.platform === "darwin" ? PathScurryDarwin : opts.platform ? PathScurryPosix : PathScurry;
+			this.scurry = new Scurry(this.cwd, {
+				nocase: opts.nocase,
+				fs: opts.fs
+			});
+		}
+		this.nocase = this.scurry.nocase;
+		const nocaseMagicOnly = this.platform === "darwin" || this.platform === "win32";
+		const mmo = {
+			...opts,
+			dot: this.dot,
+			matchBase: this.matchBase,
+			nobrace: this.nobrace,
+			nocase: this.nocase,
+			nocaseMagicOnly,
+			nocomment: true,
+			noext: this.noext,
+			nonegate: true,
+			optimizationLevel: 2,
+			platform: this.platform,
+			windowsPathsNoEscape: this.windowsPathsNoEscape,
+			debug: !!this.opts.debug
+		};
+		const mms = this.pattern.map((p) => new Minimatch(p, mmo));
+		const [matchSet, globParts] = mms.reduce((set, m) => {
+			set[0].push(...m.set);
+			set[1].push(...m.globParts);
+			return set;
+		}, [[], []]);
+		this.patterns = matchSet.map((set, i) => {
+			const g = globParts[i];
+			/* c8 ignore start */
+			if (!g) throw new Error("invalid pattern object");
+			/* c8 ignore stop */
+			return new Pattern(set, g, 0, this.platform);
+		});
+	}
+	async walk() {
+		return [...await new GlobWalker(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).walk()];
+	}
+	walkSync() {
+		return [...new GlobWalker(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).walkSync()];
+	}
+	stream() {
+		return new GlobStream(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).stream();
+	}
+	streamSync() {
+		return new GlobStream(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).streamSync();
+	}
+	/**
+	* Default sync iteration function. Returns a Generator that
+	* iterates over the results.
+	*/
+	iterateSync() {
+		return this.streamSync()[Symbol.iterator]();
+	}
+	[Symbol.iterator]() {
+		return this.iterateSync();
+	}
+	/**
+	* Default async iteration function. Returns an AsyncGenerator that
+	* iterates over the results.
+	*/
+	iterate() {
+		return this.stream()[Symbol.asyncIterator]();
+	}
+	[Symbol.asyncIterator]() {
+		return this.iterate();
+	}
+};
+
+//#endregion
+//#region node_modules/glob/dist/esm/has-magic.js
+/**
+* Return true if the patterns provided contain any magic glob characters,
+* given the options provided.
+*
+* Brace expansion is not considered "magic" unless the `magicalBraces` option
+* is set, as brace expansion just turns one string into an array of strings.
+* So a pattern like `'x{a,b}y'` would return `false`, because `'xay'` and
+* `'xby'` both do not contain any magic glob characters, and it's treated the
+* same as if you had called it on `['xay', 'xby']`. When `magicalBraces:true`
+* is in the options, brace expansion _is_ treated as a pattern having magic.
+*/
+const hasMagic = (pattern, options = {}) => {
+	if (!Array.isArray(pattern)) pattern = [pattern];
+	for (const p of pattern) if (new Minimatch(p, options).hasMagic()) return true;
+	return false;
+};
+
+//#endregion
+//#region node_modules/glob/dist/esm/index.js
+function globStreamSync(pattern, options = {}) {
+	return new Glob(pattern, options).streamSync();
+}
+function globStream(pattern, options = {}) {
+	return new Glob(pattern, options).stream();
+}
+function globSync(pattern, options = {}) {
+	return new Glob(pattern, options).walkSync();
+}
+async function glob_(pattern, options = {}) {
+	return new Glob(pattern, options).walk();
+}
+function globIterateSync(pattern, options = {}) {
+	return new Glob(pattern, options).iterateSync();
+}
+function globIterate(pattern, options = {}) {
+	return new Glob(pattern, options).iterate();
+}
+const streamSync = globStreamSync;
+const stream = Object.assign(globStream, { sync: globStreamSync });
+const iterateSync = globIterateSync;
+const iterate = Object.assign(globIterate, { sync: globIterateSync });
+const sync = Object.assign(globSync, {
+	stream: globStreamSync,
+	iterate: globIterateSync
+});
+const glob = Object.assign(glob_, {
+	glob: glob_,
+	globSync,
+	sync,
+	globStream,
+	stream,
+	globStreamSync,
+	streamSync,
+	globIterate,
+	iterate,
+	globIterateSync,
+	iterateSync,
+	Glob,
+	hasMagic,
+	escape,
+	unescape
+});
+glob.glob = glob;
+
+//#endregion
+//#region src/cli/commands/resume-drift-detector.ts
+const DEFAULT_SCAN_GLOBS = ["packages/*/src/**/*.ts", "src/**/*.ts"];
+/**
+* Detect manifest-vs-working-tree drift for `substrate resume`.
+*
+* Scans files matching the configured glob patterns using the `glob` library.
+* For each story entry in `manifest.per_story_state` where
+* `phase === 'IN_STORY_CREATION'` AND `status === 'dispatched'`, checks whether
+* any scanned file has an mtime newer than the story's `started_at` timestamp.
+* If so, the manifest is considered drifted.
+*
+* Scan globs are read from the `SUBSTRATE_RESUME_DRIFT_SCAN_GLOBS` environment
+* variable (comma-separated), falling back to the defaults:
+* "packages/&#42;/src/&#42;&#42;/&#42;.ts" and "src/&#42;&#42;/&#42;.ts"
+*
+* @param manifest    - The run manifest data (parsed and validated from disk)
+* @param projectRoot - Absolute path to the project root for glob scanning
+* @returns `{ drifted, evidence }` where `evidence` contains up to 3 sample
+*          newer files per drifted story entry.
+*/
+async function detectManifestDriftAgainstWorkingTree(manifest, projectRoot) {
+	const envGlobs = process.env["SUBSTRATE_RESUME_DRIFT_SCAN_GLOBS"];
+	const scanGlobs = envGlobs !== void 0 && envGlobs.trim() !== "" ? envGlobs.split(",").map((g) => g.trim()).filter(Boolean) : DEFAULT_SCAN_GLOBS;
+	const qualifying = Object.entries(manifest.per_story_state).filter(([, s]) => s.phase === "IN_STORY_CREATION" && s.status === "dispatched");
+	if (qualifying.length === 0) return {
+		drifted: false,
+		evidence: []
+	};
+	const scannedAbsPaths = await glob(scanGlobs, {
+		cwd: projectRoot,
+		absolute: true,
+		nodir: true
+	});
+	if (scannedAbsPaths.length === 0) return {
+		drifted: false,
+		evidence: []
+	};
+	const evidence = [];
+	for (const [storyKey, storyState] of qualifying) {
+		const storyTimestampMs = new Date(storyState.started_at).getTime();
+		const newerFiles = [];
+		for (const absPath of scannedAbsPaths) try {
+			const { mtimeMs } = await promises.stat(absPath);
+			if (mtimeMs > storyTimestampMs) newerFiles.push(relative(projectRoot, absPath).replace(/\\/g, "/"));
+		} catch {}
+		if (newerFiles.length > 0) evidence.push({
+			storyKey,
+			sampleFiles: newerFiles.slice(0, 3),
+			totalNewerFiles: newerFiles.length
+		});
+	}
+	return {
+		drifted: evidence.length > 0,
+		evidence
+	};
+}
+
 //#endregion
 //#region src/cli/commands/resume.ts
 const logger$14 = createLogger("resume-cmd");
 /**
+* Format a human-readable duration from an ISO-8601 timestamp to "now".
+*/
+function formatAgo(isoTimestamp) {
+	const diffMs = Date.now() - new Date(isoTimestamp).getTime();
+	const totalSeconds = Math.max(0, Math.floor(diffMs / 1e3));
+	if (totalSeconds < 60) return `${totalSeconds} second${totalSeconds === 1 ? "" : "s"} ago`;
+	const minutes = Math.floor(totalSeconds / 60);
+	if (minutes < 60) return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+	const days = Math.floor(hours / 24);
+	return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+/**
+* Format the drift error message shown to the operator when drift is detected.
+* The output must contain the substring "manifest drift detected" (checked by AC5 test).
+*/
+function formatDriftError(result, manifest) {
+	const lines = [];
+	for (const ev of result.evidence) {
+		const storyState = manifest.per_story_state[ev.storyKey];
+		const recordedAt = storyState?.started_at ?? "unknown";
+		const ago = formatAgo(recordedAt);
+		const sampleList = ev.sampleFiles.join(", ");
+		const fileCount = ev.totalNewerFiles;
+		lines.push(`substrate resume: manifest drift detected for story ${ev.storyKey}`);
+		lines.push(`  manifest phase: IN_STORY_CREATION dispatched (recorded ${ago})`);
+		lines.push(`  working tree:   ${fileCount} file${fileCount === 1 ? "" : "s"} newer than manifest (sample: ${sampleList})`);
+		lines.push("");
+	}
+	lines.push("This usually means the orchestrator died after writing dev-story output but", "before persisting the phase advancement (obs_2026-05-03_022 class).", "Re-dispatching from IN_STORY_CREATION would clobber that work.", "", "Recovery options:", "  1. Inspect the working tree, validate dev-story output, then commit it", "     as if the pipeline had shipped LGTM — see obs_022 recovery runbook.", "  2. To proceed with re-dispatch anyway (clobbering disk state),", "     re-run with --force-from-manifest.");
+	return lines.join("\n");
+}
+/**
 * Map internal orchestrator phase names to pipeline event protocol phase names.
 */
 function mapInternalPhaseToEventPhase(internalPhase) {
@@ -3064,6 +6865,20 @@ async function runResumeAction(options) {
 	const dbRoot = await resolveMainRepoRoot(projectRoot);
 	const packPath = join(dbRoot, "packs", packName);
 	const dbPath = join(dbRoot, ".substrate", "substrate.db");
+	if (!options.forceFromManifest) {
+		const { manifest: runManifest } = await resolveRunManifest(dbRoot, specifiedRunId ?? void 0);
+		if (runManifest !== null) try {
+			const manifestData = await runManifest.read();
+			const driftResult = await detectManifestDriftAgainstWorkingTree(manifestData, projectRoot);
+			if (driftResult.drifted) {
+				const errMsg = formatDriftError(driftResult, manifestData);
+				process.stderr.write(errMsg + "\n");
+				return 1;
+			}
+		} catch (driftErr) {
+			logger$14.debug({ err: driftErr }, "manifest drift check failed — proceeding with resume");
+		}
+	}
 	const doltDir = join(dbRoot, ".substrate", "state", ".dolt");
 	if (!existsSync$1(dbPath) && !existsSync$1(doltDir)) {
 		const errorMsg = `Decision store not initialized. Run 'substrate init' first.`;
@@ -3394,7 +7209,8 @@ async function runFullPipelineFromPhase(options) {
 							run_id: payload.runId,
 							active_dispatches: payload.activeDispatches,
 							completed_dispatches: payload.completedDispatches,
-							queued_dispatches: payload.queuedDispatches
+							queued_dispatches: payload.queuedDispatches,
+							...payload.perStoryState !== void 0 ? { per_story_state: payload.perStoryState } : {}
 						});
 					});
 				}
@@ -3493,7 +7309,7 @@ async function runFullPipelineFromPhase(options) {
 	}
 }
 function registerResumeCommand(program, _version = "0.0.0", projectRoot = process.cwd(), registry) {
-	program.command("resume").description("Resume a previously interrupted pipeline run").option("--run-id <id>", "Pipeline run ID to resume (defaults to latest)").option("--pack <name>", "Methodology pack name", "bmad").option("--stop-after <phase>", "Stop pipeline after this phase completes (overrides saved state)").option("--concurrency <n>", "Maximum parallel conflict groups", (v) => parseInt(v, 10), 3).option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").option("--events", "Emit structured NDJSON events on stdout for programmatic consumption").option("--max-review-cycles <n>", "Maximum review cycles per story (default: 2)", (v) => parseInt(v, 10), 2).option("--agent <id>", "Agent backend: claude-code (default), codex, or gemini").action(async (opts) => {
+	program.command("resume").description("Resume a previously interrupted pipeline run").option("--run-id <id>", "Pipeline run ID to resume (defaults to latest)").option("--pack <name>", "Methodology pack name", "bmad").option("--stop-after <phase>", "Stop pipeline after this phase completes (overrides saved state)").option("--concurrency <n>", "Maximum parallel conflict groups", (v) => parseInt(v, 10), 3).option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").option("--events", "Emit structured NDJSON events on stdout for programmatic consumption").option("--max-review-cycles <n>", "Maximum review cycles per story (default: 2)", (v) => parseInt(v, 10), 2).option("--agent <id>", "Agent backend: claude-code (default), codex, or gemini").option("--force-from-manifest", "Bypass manifest drift check and proceed with re-dispatch (Story 66-3 / obs_2026-05-03_022 fix #3)").action(async (opts) => {
 		const outputFormat = opts.outputFormat === "json" ? "json" : "human";
 		const exitCode = await runResumeAction({
 			runId: opts.runId,
@@ -3505,6 +7321,7 @@ function registerResumeCommand(program, _version = "0.0.0", projectRoot = proces
 			events: opts.events,
 			maxReviewCycles: opts.maxReviewCycles,
 			agent: opts.agent,
+			forceFromManifest: opts.forceFromManifest,
 			registry
 		});
 		process.exitCode = exitCode;
@@ -3667,7 +7484,7 @@ async function runStatusAction(options) {
 			logger$13.debug({ err }, "Work graph query failed, continuing without work graph data");
 		}
 		if (run === void 0) {
-			const { inspectProcessTree: inspectProcessTree$1 } = await import("../health-BdsvEnfm.js");
+			const { inspectProcessTree: inspectProcessTree$1 } = await import("../health-HmyFdWEf.js");
 			const substrateDirPath = join(projectRoot, ".substrate");
 			const processInfo = inspectProcessTree$1({
 				projectRoot,
@@ -3746,6 +7563,14 @@ async function runStatusAction(options) {
 			const completedCount = storyMetricsRows.filter((r) => r.result === "success").length;
 			const storiesPerHour = pipelineWallClockMs > 0 ? Math.round(completedCount / (pipelineWallClockMs / 36e5) * 100) / 100 : 0;
 			const totalCostUsd = storyMetricsRows.reduce((sum, r) => sum + (r.cost_usd ?? 0), 0);
+			let latestHeartbeatPerStoryState;
+			const heartbeatSnapshotPath = join(dbRoot, ".substrate", "latest-heartbeat-per-story-state.json");
+			try {
+				if (existsSync$1(heartbeatSnapshotPath)) {
+					const raw = readFileSync$1(heartbeatSnapshotPath, "utf-8");
+					latestHeartbeatPerStoryState = JSON.parse(raw);
+				}
+			} catch {}
 			const enhancedOutput = {
 				...statusOutput,
 				story_metrics: storyMetricsV2,
@@ -3758,7 +7583,8 @@ async function runStatusAction(options) {
 					cost_usd: totalCostUsd
 				},
 				story_states: storeStories,
-				workGraph: workGraph ?? null
+				workGraph: workGraph ?? null,
+				latest_heartbeat_per_story_state: latestHeartbeatPerStoryState ?? {}
 			};
 			process.stdout.write(formatOutput(enhancedOutput, "json", true) + "\n");
 		} else {
@@ -4623,7 +8449,7 @@ function defaultSupervisorDeps() {
 				if (cached === null) {
 					const { AdapterRegistry: AR } = await import(
 						/* @vite-ignore */
-						"../adapter-registry-CcahKCG1.js"
+						"../adapter-registry-k7ZX3Bz6.js"
 );
 					cached = new AR();
 					await cached.discoverAndRegister();
@@ -5190,11 +9016,11 @@ async function runSupervisorAction(options, deps = {}) {
 						try {
 							const { createExperimenter } = await import(
 								/* @vite-ignore */
-								"../experimenter-2KGF4bLj.js"
+								"../experimenter-DxxwicpK.js"
 );
 							const { getLatestRun: getLatest } = await import(
 								/* @vite-ignore */
-								"../decisions-UFV5YFaW.js"
+								"../decisions-4F91LrVD.js"
 );
 							const expAdapter = createDatabaseAdapter({
 								backend: "auto",
@@ -5204,7 +9030,7 @@ async function runSupervisorAction(options, deps = {}) {
 								await initSchema(expAdapter);
 								const { runRunAction: runPipeline } = await import(
 									/* @vite-ignore */
-									"../run-CkFWtcjl.js"
+									"../run-BF8oeJhG.js"
 );
 								const runStoryFn = async (opts) => {
 									const exitCode = await runPipeline({
@@ -5736,7 +9562,7 @@ async function runMetricsAction(options) {
 			const routingConfigPath = join(dbDir, "routing.yml");
 			let routingConfig = null;
 			if (existsSync$1(routingConfigPath)) try {
-				const { loadModelRoutingConfig } = await import("../routing-BNGNSI0w.js");
+				const { loadModelRoutingConfig } = await import("../routing-0ykvBl_4.js");
 				routingConfig = loadModelRoutingConfig(routingConfigPath);
 			} catch {}
 			if (routingConfig === null) routingConfig = {
@@ -9372,8 +13198,8 @@ async function createProgram() {
 /** Fire-and-forget startup version check (story 8.3, AC3/AC5) */
 function checkForUpdatesInBackground(currentVersion) {
 	if (process.env.SUBSTRATE_NO_UPDATE_CHECK === "1") return;
-	import("../upgrade-Csv0GRft.js").then(async () => {
-		const { createVersionManager } = await import("../version-manager-impl-C-mrgne3.js");
+	import("../upgrade-C8LAnB6W.js").then(async () => {
+		const { createVersionManager } = await import("../version-manager-impl-DaA_ALYK.js");
 		const vm = createVersionManager();
 		const result = await vm.checkForUpdates();
 		if (result.updateAvailable) {