@let-value/translate-extract 1.1.6-beta.3 → 1.2.3

package/dist/{run-Bv3fv1N8.mjs → run-CzeTVOug.mjs}

@@ -12,52 +12,25 @@ import { getFormula, getNPlurals } from "plural-forms";
 import { isDeepStrictEqual } from "node:util";
 import glob from "fast-glob";
 //#region src/plugins/cleanup/cleanup.ts
-const namespace$2 = "cleanup";
 function cleanup() {
 	return {
 		name: "cleanup",
 		setup(build) {
 			build.context.logger?.debug("cleanup plugin initialized");
-			const processed = /* @__PURE__ */ new Set();
-			const generated = /* @__PURE__ */ new Set();
-			const dirs = /* @__PURE__ */ new Set();
-			let dispatched = false;
-			build.onResolve({
-				namespace: namespace$2,
-				filter: /.*/
-			}, ({ path }) => {
-				generated.add(path);
-				dirs.add(dirname(path));
-				Promise.all([
-					build.defer("source"),
-					build.defer("translate"),
-					build.defer(namespace$2)
-				]).then(() => {
-					if (dispatched) return;
-					dispatched = true;
-					for (const path of dirs.values()) build.process({
-						entrypoint: path,
-						path,
-						namespace: namespace$2,
-						data: void 0
-					});
-				});
-			});
-			build.onProcess({
-				namespace: namespace$2,
-				filter: /.*/
-			}, async ({ path }) => {
-				if (processed.has(path)) return;
-				processed.add(path);
-				const files = await fs.readdir(path).catch(() => []);
-				for (const f of files.filter((p) => p.endsWith(".po"))) {
-					const full = join(path, f);
-					const contents = await fs.readFile(full).catch(() => void 0);
-					if (!contents) continue;
-					const parsed = gettextParser.po.parse(contents);
-					const hasTranslations = Object.entries(parsed.translations || {}).some(([ctx, msgs]) => Object.keys(msgs).some((id) => !(ctx === "" && id === "")));
-					if (!hasTranslations && generated.has(full)) await fs.unlink(full);
-					if (hasTranslations && !generated.has(full)) build.context.logger?.warn({ path: full }, "stray translation file");
+			build.onOutputs(async ({ outputs }) => {
+				const generated = new Set(outputs);
+				const dirs = new Set(outputs.map((path) => dirname(path)));
+				for (const dir of dirs) {
+					const files = await fs.readdir(dir).catch(() => []);
+					for (const file of files.filter((name) => name.endsWith(".po"))) {
+						const full = join(dir, file);
+						const contents = await fs.readFile(full).catch(() => void 0);
+						if (!contents) continue;
+						const parsed = gettextParser.po.parse(contents);
+						const hasTranslations = Object.entries(parsed.translations || {}).some(([ctx, msgs]) => Object.keys(msgs).some((id) => !(ctx === "" && id === "")));
+						if (!hasTranslations && generated.has(full)) await fs.unlink(full);
+						if (hasTranslations && !generated.has(full)) build.context.logger?.warn({ path: full }, "stray translation file");
+					}
 				}
 			});
 		}
@@ -258,7 +231,7 @@ const messageQuery$1 = notInPlural(withComment({
 	pattern: callPattern("message", messageArgs),
 	extract: extractMessage("message")
 }));
-const allowed$1 = new Set([
+const allowed$1 = /* @__PURE__ */ new Set([
 	"string",
 	"object",
 	"template_string"
@@ -401,7 +374,7 @@ const gettextQuery = withComment({
 	pattern: callPattern("gettext", messageArgs),
 	extract: extractMessage("gettext")
 });
-const allowed = new Set([
+const allowed = /* @__PURE__ */ new Set([
 	"string",
 	"object",
 	"template_string",
@@ -573,7 +546,7 @@ function findTsconfig(dir) {
 	}
 }
 const resolverCache = /* @__PURE__ */ new Map();
-const builtins = new Set([...builtinModules, ...builtinModules.map((name) => `node:${name}`)]);
+const builtins = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((name) => `node:${name}`)]);
 function isBuiltin(spec) {
 	if (builtins.has(spec)) return true;
 	const [base, subpath] = (spec.startsWith("node:") ? spec.slice(5) : spec).split("/", 2);
@@ -650,58 +623,29 @@ function resolveImportResults(file, imports) {
 //#endregion
 //#region src/plugins/core/core.ts
 const filter$1 = /\.([cm]?tsx?|jsx?)$/;
-const namespace$1 = "source";
 function core() {
 	return {
 		name: "core",
 		setup(build) {
 			build.context.logger?.debug("core plugin initialized");
-			build.onResolve({
-				filter: filter$1,
-				namespace: namespace$1
-			}, ({ entrypoint, path, import: imp, data }) => {
-				return {
-					entrypoint,
-					namespace: namespace$1,
-					path: resolve(path),
-					import: imp,
-					data
-				};
-			});
-			build.onLoad({
-				filter: filter$1,
-				namespace: namespace$1
-			}, async ({ entrypoint, path }) => {
-				return {
-					entrypoint,
-					path,
-					namespace: namespace$1,
-					data: await readFile(path, "utf8")
-				};
-			});
-			build.onProcess({
-				filter: filter$1,
-				namespace: namespace$1
-			}, ({ entrypoint, path, data }) => {
-				const result = parseSource$1(data, path);
+			build.onLoad(filter$1, ({ path }) => readFile(path, "utf8"));
+			build.onProcess(filter$1, ({ entrypoint, path, contents, emit }) => {
+				const result = parseSource$1(contents, path);
 				if (result.entrypoint && entrypoint !== path) {
-					build.source(path);
-					return {
-						entrypoint,
-						path,
-						namespace: namespace$1,
-						data: []
-					};
+					build.source({
+						entrypoint: path,
+						path
+					});
+					return true;
 				}
 				const { translations, imports, warnings } = result;
 				if (build.context.config.walk) {
 					const { resolved, unresolved } = resolveImportResults(path, imports);
 					for (const result of resolved) {
 						if (build.context.paths.has(result.path)) continue;
-						build.resolve({
+						build.source({
 							entrypoint,
 							path: result.path,
-							namespace: namespace$1,
 							import: result.import
 						});
 					}
@@ -710,19 +654,14 @@ function core() {
 						if (imp && isExcluded({
 							entrypoint,
 							path: spec,
-							namespace: namespace$1,
+							namespace: "source",
 							import: imp
 						}, build.context.config.exclude)) continue;
 						build.context.logger?.warn(`Unable to resolve import "${spec}" from ${path}${error ? `: ${error}` : ""}`);
 					}
 				}
 				for (const warning of warnings) build.context.logger?.warn(`${warning.error} at ${warning.reference}`);
-				build.resolve({
-					entrypoint,
-					path,
-					namespace: "translate",
-					data: translations
-				});
+				emit(translations);
 			});
 		}
 	};
@@ -763,7 +702,7 @@ function collect(source, locale) {
 }
 //#endregion
 //#region src/plugins/po/hasChanges.ts
-const IGNORED_HEADER_KEYS = new Set(["pot-creation-date", "po-revision-date"]);
+const IGNORED_HEADER_KEYS = /* @__PURE__ */ new Set(["pot-creation-date", "po-revision-date"]);
 const IGNORED_HEADER_LINE_PREFIXES = ["pot-creation-date:", "po-revision-date:"];
 function normalizeHeaderString(value) {
 	const lines = value.split("\n");
@@ -779,7 +718,7 @@ function normalizeHeaderString(value) {
 	if (hadTrailingNewline && filtered[filtered.length - 1] !== "") filtered.push("");
 	return filtered.join("\n");
 }
-function normalize(translations) {
+function normalize$1(translations) {
 	const compiled = gettextParser.po.compile(translations);
 	const parsed = gettextParser.po.parse(compiled);
 	if (parsed.headers) {
@@ -793,7 +732,9 @@ function normalize(translations) {
 }
 function hasChanges(left, right) {
 	if (!right) return true;
-	return !isDeepStrictEqual(normalize(left), normalize(right));
+	const normalizedLeft = normalize$1(left);
+	const normalizedRight = normalize$1(right);
+	return !isDeepStrictEqual(normalizedLeft, normalizedRight);
 }
 //#endregion
 //#region src/plugins/po/merge.ts
@@ -890,74 +831,39 @@ function merge(sources, existing, obsolete, locale, generatedAt) {
 }
 //#endregion
 //#region src/plugins/po/po.ts
-const namespace = "translate";
 function po() {
 	return {
 		name: "po",
 		setup(build) {
 			build.context.logger?.debug("po plugin initialized");
 			const collections = /* @__PURE__ */ new Map();
-			let dispatched = false;
-			build.onResolve({
-				filter: /.*/,
-				namespace
-			}, async ({ entrypoint, path, data }) => {
-				if (!data || !Array.isArray(data)) return;
-				for (const locale of build.context.config.locales) {
+			build.onCollected(({ entrypoint, files, output }) => {
+				for (const { path, translations } of files) for (const locale of build.context.config.locales) {
 					const destination = build.context.config.destination({
 						entrypoint,
 						locale,
 						path
 					});
-					if (!collections.has(destination)) collections.set(destination, {
+					const collection = collections.get(destination);
+					if (collection) {
+						collection.translations.push(...translations);
+						continue;
+					}
+					const created = {
 						locale,
-						translations: []
-					});
-					collections.get(destination)?.translations.push(...data);
-				}
-				Promise.all([build.defer("source"), build.defer(namespace)]).then(() => {
-					if (dispatched) return;
-					dispatched = true;
-					for (const path of collections.keys()) build.load({
-						entrypoint,
-						path,
-						namespace
+						translations: [...translations]
+					};
+					collections.set(destination, created);
+					output(destination, async () => {
+						const contents = await fs.readFile(destination).catch(() => void 0);
+						const existing = contents ? gettextParser.po.parse(contents) : void 0;
+						const out = merge([{ translations: collect(created.translations, created.locale) }], existing, build.context.config.obsolete, created.locale, build.context.generatedAt);
+						if (hasChanges(out, existing)) {
+							await fs.mkdir(dirname(destination), { recursive: true });
+							await fs.writeFile(destination, gettextParser.po.compile(out));
+						}
 					});
-				});
-			});
-			build.onLoad({
-				filter: /.*\.po$/,
-				namespace
-			}, async ({ entrypoint, path }) => {
-				const contents = await fs.readFile(path).catch(() => void 0);
-				return {
-					entrypoint,
-					path,
-					namespace,
-					data: contents ? gettextParser.po.parse(contents) : void 0
-				};
-			});
-			build.onProcess({
-				filter: /.*\.po$/,
-				namespace
-			}, async ({ entrypoint, path, data }) => {
-				const collected = collections.get(path);
-				if (!collected) {
-					build.context.logger?.warn({ path }, "no translations collected for this path");
-					return;
-				}
-				const { locale, translations } = collected;
-				const out = merge([{ translations: collect(translations, locale) }], data, build.context.config.obsolete, locale, build.context.generatedAt);
-				if (hasChanges(out, data)) {
-					await fs.mkdir(dirname(path), { recursive: true });
-					await fs.writeFile(path, gettextParser.po.compile(out));
 				}
-				build.resolve({
-					entrypoint,
-					path,
-					namespace: "cleanup",
-					data: translations
-				});
 			});
 		}
 	};
@@ -1258,35 +1164,576 @@ function react() {
 		name: "react",
 		setup(build) {
 			build.context.logger?.debug("react plugin initialized");
-			build.onProcess({
-				filter,
-				namespace: "source"
-			}, ({ entrypoint, path, data }) => {
-				const { translations, warnings } = parseSource(data, path);
+			build.onProcess(filter, ({ path, contents, emit }) => {
+				const { translations, warnings } = parseSource(contents, path);
 				for (const warning of warnings) build.context.logger?.warn(`${warning.error} at ${warning.reference}`);
-				build.resolve({
-					entrypoint,
-					path,
-					namespace: "translate",
-					data: translations
-				});
+				emit(translations);
 			});
 		}
 	};
 }
 //#endregion
-//#region src/defer.ts
-var Defer = class {
-	pending = 0;
-	promise = Promise.resolve();
-	resolve;
-	enqueue() {
-		if (this.pending++ === 0) this.promise = new Promise((res) => {
-			this.resolve = res;
+//#region ../graph/dist/index.mjs
+var CycleError = class extends Error {
+	constructor(dependency, dependent) {
+		super(`Adding edge "${dependency}" -> "${dependent}" would create a cycle`);
+		this.name = "CycleError";
+	}
+};
+var SkippedError = class extends Error {
+	constructor(id) {
+		super(`Node "${id}" was skipped because a dependency failed or the run was aborted`);
+		this.name = "SkippedError";
+	}
+};
+var NodeState = class {
+	id;
+	status = "pending";
+	result;
+	reason;
+	lazy = false;
+	/**
+	* Dependencies that have not fulfilled yet. Readiness is maintained as
+	* edges are added and dependencies settle, so scheduling never has to
+	* rescan the pending set.
+	*/
+	unresolved = 0;
+	/** Whether the node is already sitting in the ready queue. */
+	queued = false;
+	/** Resumers of demanders suspended on this node, flushed on settle. */
+	waiters;
+	/** Ordered data dependencies, passed as run arguments. */
+	arguments_;
+	/** All dependencies, including ordering-only edges added via connect(). */
+	dependencies = /* @__PURE__ */ new Set();
+	dependents = /* @__PURE__ */ new Set();
+	execute;
+	constructor(id, arguments_, execute) {
+		this.id = id;
+		this.arguments_ = arguments_;
+		this.execute = execute;
+		for (const dependency of arguments_) this.dependencies.add(dependency);
+	}
+	get value() {
+		if (this.status !== "fulfilled") throw new Error(`Node "${this.id}" has no value (status: ${this.status})`);
+		return this.result;
+	}
+	get error() {
+		return this.reason;
+	}
+};
+/**
+* A dynamic, asynchronous DAG of computations.
+*
+* Nodes can be added before or during a run, so a running node can discover
+* and schedule new work. Edges added with {@link Graph.connect} impose
+* ordering without contributing run arguments, which lets consumers build
+* barriers: a node that only starts once a dynamically growing set of
+* predecessors has finished.
+*/
+var Graph = class {
+	#nodes = /* @__PURE__ */ new Map();
+	#root;
+	#pending = /* @__PURE__ */ new Set();
+	#dormant = /* @__PURE__ */ new Set();
+	/** Pending nodes whose dependencies have all fulfilled. */
+	#ready = [];
+	/** Demanders that finished waiting and need a slot before resuming. */
+	#slotWaiters = [];
+	#runningCount = 0;
+	#suspendedCount = 0;
+	#concurrency = Infinity;
+	#controller;
+	#finish;
+	#started = false;
+	#finished = false;
+	#errors = [];
+	constructor() {
+		INTERNALS.set(this, {
+			kinds: /* @__PURE__ */ new Map(),
+			workers: /* @__PURE__ */ new Map(),
+			wrappers: /* @__PURE__ */ new Map(),
+			frozen: false
+		});
+		this.#root = new Scope(this, void 0, "");
+	}
+	/** The root scope. Nodes added here belong to no named scope. */
+	get root() {
+		return this.#root;
+	}
+	/** Creates or returns a named child scope of the root scope. */
+	scope(name) {
+		return this.#root.scope(name);
+	}
+	/** Declares a typed node kind. Kind names are unique per graph. */
+	kind(name) {
+		const internals = INTERNALS.get(this);
+		if (internals.kinds.has(name)) throw new Error(`Kind "${name}" is already registered`);
+		const kind = { name };
+		internals.kinds.set(name, kind);
+		return kind;
+	}
+	/**
+	* Registers a worker that runs for every node of `source`, in the same
+	* scope as that node. Worker results form their own kind, so they can be
+	* awaited and collected with scope.completion(). Part of the graph's
+	* definition: allowed until run() starts, and applies to nodes added
+	* before the registration as well.
+	*/
+	each(source, name, worker) {
+		const internals = INTERNALS.get(this);
+		if (internals.frozen) throw new Error(`Cannot register worker "${name}" after run() started`);
+		const kind = this.kind(name);
+		const registrations = internals.workers.get(source.name) ?? [];
+		registrations.push({
+			kind,
+			worker
+		});
+		internals.workers.set(source.name, registrations);
+		return kind;
+	}
+	/**
+	* Interposes on every node of a kind: consumers of the node receive the
+	* outermost wrapper's value instead of the raw computation. The chain is
+	* materialized as real intermediate nodes ("<id>@raw", "<id>@<name>"),
+	* evaluated on demand: a wrapper that never calls next() (e.g. a cache
+	* hit) keeps the inner nodes from running at all. Wrappers compose; the
+	* last registered one is outermost. Part of the graph's definition:
+	* allowed until run() starts.
+	*/
+	wrap(kind, name, wrapper) {
+		const internals = INTERNALS.get(this);
+		if (internals.frozen) throw new Error(`Cannot register wrapper "${name}" after run() started`);
+		const registrations = internals.wrappers.get(kind.name) ?? [];
+		registrations.push({
+			name,
+			wrap: wrapper
+		});
+		internals.wrappers.set(kind.name, registrations);
+	}
+	/** Whether `node` transitively depends on `dependency`. */
+	dependsOn(node, dependency) {
+		const target = this.#resolve(dependency);
+		const stack = [...this.#resolve(node).dependencies];
+		const seen = /* @__PURE__ */ new Set();
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (current === target) return true;
+			if (seen.has(current)) continue;
+			seen.add(current);
+			stack.push(...current.dependencies);
+		}
+		return false;
+	}
+	add(id, options) {
+		if (this.#finished) throw new Error(`Cannot add node "${id}": the graph has already finished`);
+		if (this.#nodes.has(id)) throw new Error(`Node "${id}" already exists`);
+		const dependencies = (options.dependencies ?? []).map((dependency) => this.#resolve(dependency));
+		const node = new NodeState(id, dependencies, options.run);
+		node.lazy = options.lazy ?? false;
+		let doomed;
+		for (const dependency of dependencies) {
+			dependency.dependents.add(node);
+			if (dependency.status === "rejected" || dependency.status === "skipped") doomed ??= dependency;
+			else if (dependency.status !== "fulfilled") node.unresolved += 1;
+		}
+		this.#nodes.set(id, node);
+		if (node.lazy) this.#dormant.add(node);
+		else {
+			this.#pending.add(node);
+			for (const dependency of dependencies) this.#wake(dependency);
+		}
+		if (doomed) this.#settle(node, "skipped", void 0, new SkippedError(node.id));
+		else if (!node.lazy) this.#enqueue(node);
+		if (this.#started) queueMicrotask(() => this.#pump());
+		return node;
+	}
+	/**
+	* Adds an ordering-only edge: `dependent` will not start until
+	* `dependency` has fulfilled. The dependency's value is not passed to the
+	* dependent's run function; read it from the node handle if needed.
+	*/
+	connect(dependency, dependent) {
+		const from = this.#resolve(dependency);
+		const to = this.#resolve(dependent);
+		if (to.status !== "pending") throw new Error(`Cannot add dependency to node "${to.id}": it has already started`);
+		if (from === to || this.#reaches(to, from)) throw new CycleError(from.id, to.id);
+		if (to.dependencies.has(from)) return;
+		to.dependencies.add(from);
+		from.dependents.add(to);
+		if (from.status === "rejected" || from.status === "skipped") {
+			this.#settle(to, "skipped", void 0, new SkippedError(to.id));
+			return;
+		}
+		if (from.status !== "fulfilled") to.unresolved += 1;
+		if (!this.#dormant.has(to)) this.#wake(from);
+		if (this.#started) queueMicrotask(() => this.#pump());
+	}
+	get(id) {
+		return this.#nodes.get(id);
+	}
+	get nodes() {
+		return this.#nodes;
+	}
+	/**
+	* Runs the graph until every node has settled, including nodes added
+	* while running. Rejects with an AggregateError if any node rejected, or
+	* with the abort reason if the signal aborted. Can only be called once.
+	*/
+	async run(options = {}) {
+		if (this.#started) throw new Error("Graph is already running or has finished");
+		Scope.materialize(this.#root);
+		INTERNALS.get(this).frozen = true;
+		this.#started = true;
+		this.#concurrency = options.concurrency ?? Infinity;
+		if (this.#concurrency < 1) throw new Error("concurrency must be at least 1");
+		this.#controller = new AbortController();
+		const signal = options.signal;
+		if (signal) if (signal.aborted) this.#controller.abort(signal.reason);
+		else signal.addEventListener("abort", () => {
+			this.#controller?.abort(signal.reason);
+			this.#pump();
+		});
+		return new Promise((resolve, reject) => {
+			this.#finish = {
+				resolve,
+				reject
+			};
+			this.#pump();
+		});
+	}
+	#resolve(handle) {
+		const node = this.#nodes.get(handle.id);
+		if (!node || node !== handle) throw new Error(`Node "${handle.id}" does not belong to this graph`);
+		return node;
+	}
+	#reaches(from, target) {
+		const stack = [...from.dependents];
+		const seen = /* @__PURE__ */ new Set();
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (node === target) return true;
+			if (seen.has(node)) continue;
+			seen.add(node);
+			stack.push(...node.dependents);
+		}
+		return false;
+	}
+	/** Offers a pending node to the scheduler once its dependencies are in. */
+	#enqueue(node) {
+		if (node.queued || node.unresolved > 0 || node.status !== "pending" || this.#dormant.has(node)) return;
+		node.queued = true;
+		this.#ready.push(node);
+	}
+	#pump() {
+		if (!this.#started || this.#finished || !this.#finish) return;
+		if (this.#controller?.signal.aborted) {
+			while (this.#slotWaiters.length > 0) {
+				this.#runningCount += 1;
+				this.#slotWaiters.shift()();
+			}
+			for (const node of [...this.#pending]) this.#settle(node, "skipped", void 0, new SkippedError(node.id));
+		} else {
+			while (this.#slotWaiters.length > 0 && this.#runningCount < this.#concurrency) {
+				this.#runningCount += 1;
+				this.#slotWaiters.shift()();
+			}
+			while (this.#ready.length > 0 && this.#runningCount < this.#concurrency) {
+				const node = this.#ready.shift();
+				node.queued = false;
+				if (node.unresolved === 0 && node.status === "pending") this.#start(node);
+			}
+		}
+		if (this.#pending.size === 0 && this.#runningCount === 0 && this.#suspendedCount === 0) this.#complete();
+	}
+	/** Moves a dormant lazy node (and its dormant dependencies) into scheduling. */
+	#wake(node) {
+		const stack = [node];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (!this.#dormant.delete(current)) continue;
+			this.#pending.add(current);
+			this.#enqueue(current);
+			stack.push(...current.dependencies);
+		}
+	}
+	/**
+	* Takes a concurrency slot, waiting for one when the graph is at its
+	* limit. The slot is reserved by #pump at hand-off, so a granted slot
+	* cannot be taken by anything else in the meantime.
+	*/
+	#acquire() {
+		if (this.#runningCount < this.#concurrency) {
+			this.#runningCount += 1;
+			return;
+		}
+		return new Promise((resume) => {
+			this.#slotWaiters.push(resume);
+		});
+	}
+	async #demand(demander, handle) {
+		if (demander.status !== "running") throw new Error(`Node "${demander.id}" called demand() while it is "${demander.status}": a node context is only usable for as long as its node runs`);
+		const target = this.#resolve(handle);
+		if (target === demander || this.#reaches(demander, target)) throw new CycleError(target.id, demander.id);
+		if (!demander.dependencies.has(target)) {
+			demander.dependencies.add(target);
+			target.dependents.add(demander);
+		}
+		this.#wake(target);
+		if (target.status === "pending" || target.status === "running") this.#pump();
+		if (target.status === "pending" || target.status === "running") {
+			this.#runningCount -= 1;
+			this.#suspendedCount += 1;
+			this.#pump();
+			await new Promise((resume) => {
+				(target.waiters ??= []).push(resume);
+			});
+			await this.#acquire();
+			this.#suspendedCount -= 1;
+		}
+		if (target.status === "fulfilled") return target.result;
+		if (target.status === "rejected") throw target.reason;
+		throw new SkippedError(target.id);
+	}
+	#start(node) {
+		this.#pending.delete(node);
+		node.status = "running";
+		this.#runningCount += 1;
+		const context = {
+			id: node.id,
+			signal: this.#controller?.signal,
+			demand: (handle) => this.#demand(node, handle)
+		};
+		const values = node.arguments_.map((dependency) => dependency.value);
+		Promise.resolve().then(() => node.execute(context, ...values)).then((value) => {
+			this.#runningCount -= 1;
+			this.#settle(node, "fulfilled", value, void 0);
+			this.#pump();
+		}, (reason) => {
+			this.#runningCount -= 1;
+			this.#errors.push(reason);
+			this.#settle(node, "rejected", void 0, reason);
+			this.#pump();
+		});
+	}
+	/**
+	* Settles a node and propagates the consequences to its dependents: a
+	* fulfilled node makes them one dependency readier, a failed or skipped
+	* one skips them in turn. Iterative, so a long chain of skips cannot
+	* overflow the stack.
+	*/
+	#settle(node, status, value, reason) {
+		const stack = [{
+			node,
+			status,
+			value,
+			reason
+		}];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			const settled = current.node;
+			if (settled.status !== "pending" && settled.status !== "running") continue;
+			this.#pending.delete(settled);
+			this.#dormant.delete(settled);
+			settled.status = current.status;
+			settled.result = current.value;
+			settled.reason = current.reason;
+			const waiters = settled.waiters;
+			settled.waiters = void 0;
+			waiters?.forEach((resume) => resume());
+			const doomed = current.status === "rejected" || current.status === "skipped";
+			for (const dependent of settled.dependents) {
+				if (doomed) {
+					if (dependent.status === "pending") stack.push({
+						node: dependent,
+						status: "skipped",
+						value: void 0,
+						reason: new SkippedError(dependent.id)
+					});
+					continue;
+				}
+				if (dependent.unresolved > 0) {
+					dependent.unresolved -= 1;
+					this.#enqueue(dependent);
+				}
+			}
+		}
+	}
+	#complete() {
+		const finish = this.#finish;
+		if (!finish) return;
+		for (const node of [...this.#dormant]) this.#settle(node, "skipped", void 0, new SkippedError(node.id));
+		this.#finished = true;
+		this.#finish = void 0;
+		if (this.#controller?.signal.aborted) finish.reject(this.#controller.signal.reason);
+		else if (this.#errors.length > 0) finish.reject(new AggregateError(this.#errors, "One or more graph nodes failed"));
+		else finish.resolve();
+	}
+};
+const INTERNALS = /* @__PURE__ */ new WeakMap();
+function normalize(spec) {
+	return typeof spec === "function" ? { run: spec } : spec;
+}
+/**
+* A hierarchical namespace of kinded nodes. Scopes make phase completion
+* automatic: scope.completion(kind) fulfills once every node in the scope
+* (and its descendants) has settled — including nodes that are created
+* dynamically while the graph runs — without the producers having to wire
+* any edges themselves.
+*/
+var Scope = class Scope {
+	name;
+	path;
+	#graph;
+	#parent;
+	#children = /* @__PURE__ */ new Map();
+	#entries = /* @__PURE__ */ new Map();
+	/** Nodes this scope's completions must wait for (kinded nodes + workers). */
+	#members = [];
+	#completions = /* @__PURE__ */ new Map();
+	/** @internal Use graph.scope() or scope.scope() instead. */
+	constructor(graph, parent, name) {
+		this.#graph = graph;
+		this.#parent = parent;
+		this.name = name;
+		this.path = parent && parent.path ? `${parent.path}/${name}` : name;
+	}
+	/** Creates or returns a named child scope. */
+	scope(name) {
+		let child = this.#children.get(name);
+		if (!child) {
+			child = new Scope(this.#graph, this, name);
+			this.#children.set(name, child);
+		}
+		return child;
+	}
+	get(kind, key) {
+		return this.#entries.get(kind.name)?.get(key);
+	}
+	add(kind, key, spec) {
+		if (this.get(kind, key)) throw new Error(`Node "${kind.name}:${key}" already exists in scope "${this.path || "(root)"}"`);
+		return this.#create(kind, key, normalize(spec));
+	}
+	/** Like add(), but returns the existing node if the key is already present. */
+	ensure(kind, key, spec) {
+		return this.get(kind, key) ?? this.#create(kind, key, normalize(spec));
+	}
+	/**
+	* A barrier node that fulfills once this scope is quiescent: every node
+	* in the scope and its descendants has settled, except nodes that
+	* transitively depend on the barrier itself (its consumers). Its value is
+	* the collected values of all `kind` nodes in the scope subtree. After it
+	* fires the scope is sealed: adding non-consumer nodes throws.
+	*/
+	completion(kind) {
+		const existing = this.#completions.get(kind.name);
+		if (existing) return existing;
+		const completion = this.#graph.add(`${this.#prefix()}${kind.name}:$completion`, { run: () => this.#collect(kind) });
+		this.#completions.set(kind.name, completion);
+		for (const member of this.#allMembers()) this.#attach(member, completion);
+		return completion;
+	}
+	#prefix() {
+		return this.path ? `${this.path}/` : "";
+	}
+	#create(kind, key, options) {
+		const internals = INTERNALS.get(this.#graph);
+		const dependencies = options.dependencies ?? [];
+		this.#assertOpen(`${kind.name}:${key}`, dependencies);
+		const scope = this;
+		const graph = this.#graph;
+		const id = `${this.#prefix()}${kind.name}:${key}`;
+		const node = graph.add(id, {
+			dependencies,
+			run: (context, ...values) => {
+				const scoped = {
+					id: context.id,
+					key,
+					signal: context.signal,
+					scope,
+					demand: context.demand
+				};
+				const compute = () => options.run(scoped, ...values);
+				const wrappers = internals.wrappers.get(kind.name) ?? [];
+				if (wrappers.length === 0) return compute();
+				let inner = graph.add(`${id}@raw`, {
+					lazy: true,
+					run: () => compute()
+				});
+				for (const registration of wrappers.slice(0, -1)) {
+					const previous = inner;
+					inner = graph.add(`${id}@${registration.name}`, {
+						lazy: true,
+						run: (innerContext) => registration.wrap({
+							...scoped,
+							id: innerContext.id,
+							demand: innerContext.demand
+						}, () => {
+							return innerContext.demand(previous);
+						})
+					});
+				}
+				return wrappers[wrappers.length - 1].wrap(scoped, () => context.demand(inner));
+			}
 		});
+		let byKey = this.#entries.get(kind.name);
+		if (!byKey) {
+			byKey = /* @__PURE__ */ new Map();
+			this.#entries.set(kind.name, byKey);
+		}
+		byKey.set(key, node);
+		this.#members.push(node);
+		for (let ancestor = this; ancestor; ancestor = ancestor.#parent) for (const completion of ancestor.#completions.values()) this.#attach(node, completion);
+		for (const registration of internals.workers.get(kind.name) ?? []) this.#create(registration.kind, key, {
+			dependencies: [node],
+			run: (context, value) => registration.worker(context, value, node)
+		});
+		return node;
+	}
+	/**
+	* Attaches workers registered after some nodes of their kind were
+	* already added. Runs once when the definition phase ends (run()).
+	*/
+	static materialize(scope) {
+		const internals = INTERNALS.get(scope.#graph);
+		for (const [kindName, byKey] of scope.#entries) for (const registration of internals.workers.get(kindName) ?? []) for (const [key, node] of [...byKey]) {
+			if (scope.#entries.get(registration.kind.name)?.has(key)) continue;
+			scope.#create(registration.kind, key, {
+				dependencies: [node],
+				run: (context, value) => registration.worker(context, value, node)
+			});
+		}
+		for (const child of scope.#children.values()) Scope.materialize(child);
 	}
-	dequeue() {
-		if (this.pending > 0 && --this.pending === 0) this.resolve?.();
+	/**
+	* A scope seals once a completion fires: new nodes are only allowed if
+	* they are consumers of that completion (depend on it), since the
+	* completion has already reported the scope as done.
+	*/
+	#assertOpen(label, dependencies) {
+		for (let ancestor = this; ancestor; ancestor = ancestor.#parent) for (const completion of ancestor.#completions.values()) {
+			if (completion.status === "pending") continue;
+			if (!dependencies.some((dependency) => dependency === completion || this.#graph.dependsOn(dependency, completion))) throw new Error(`Cannot add "${label}" to scope "${ancestor.path || "(root)"}": its completion "${completion.id}" has already fired`);
+		}
+	}
+	#attach(member, completion) {
+		if (completion.status !== "pending") return;
+		if (member === completion || this.#graph.dependsOn(member, completion)) return;
+		this.#graph.connect(member, completion);
+	}
+	#allMembers() {
+		const members = [...this.#members];
+		for (const child of this.#children.values()) members.push(...child.#allMembers());
+		return members;
+	}
+	#collect(kind) {
+		const values = [];
+		const byKey = this.#entries.get(kind.name);
+		if (byKey) {
+			for (const node of byKey.values()) if (node.status === "fulfilled") values.push(node.value);
+		}
+		for (const child of this.#children.values()) values.push(...child.#collect(kind));
+		return values;
 	}
 };
 //#endregion
@@ -1308,13 +1755,19 @@ async function getPaths(entrypoint) {
 	const paths = glob.isDynamicPattern(pattern) ? await glob(pattern, { onlyFiles: true }) : [entrypoint.entrypoint];
 	return new Set(paths.map((path) => resolve(path)));
 }
+function toRealPath(path) {
+	const abs = resolve(path);
+	try {
+		return realpathSync(abs);
+	} catch {
+		return abs;
+	}
+}
 async function run(entrypoint, { config, logger }) {
 	const destination = entrypoint.destination ?? config.destination;
 	const obsolete = entrypoint.obsolete ?? config.obsolete;
 	const exclude = entrypoint.exclude ?? config.exclude;
 	const walk = entrypoint.walk ?? config.walk;
-	const paths = /* @__PURE__ */ new Set();
-	const resolved = /* @__PURE__ */ new Set();
 	const context = {
 		config: {
 			...config,
@@ -1324,110 +1777,139 @@ async function run(entrypoint, { config, logger }) {
 			walk
 		},
 		generatedAt: /* @__PURE__ */ new Date(),
-		paths,
+		paths: /* @__PURE__ */ new Set(),
 		logger
 	};
 	logger?.info(entrypoint, "starting extraction");
-	const resolvers = [];
 	const loaders = [];
 	const processors = [];
-	const hooks = {
-		resolve: resolvers,
-		load: loaders,
-		process: processors
-	};
-	const pending = /* @__PURE__ */ new Map();
-	const queue = [];
-	function getDeferred(namespace) {
-		let defer = pending.get(namespace);
-		if (defer === void 0) {
-			defer = new Defer();
-			pending.set(namespace, defer);
-		}
-		return defer;
+	const collectors = [];
+	const finalizers = [];
+	const failures = [];
+	const failed = /* @__PURE__ */ new Set();
+	/** Records a failure that leaves `scope`'s translations incomplete. */
+	function fail(scope, path, error) {
+		failed.add(scope);
+		record({
+			entrypoint: scope,
+			path
+		}, error);
 	}
-	function defer(namespace) {
-		return getDeferred(namespace).promise;
+	/** Records a failure that no longer has an entrypoint to invalidate. */
+	function record(where, error) {
+		failures.push(error);
+		logger?.error({
+			...where,
+			error
+		}, "extraction failed");
 	}
-	function source(path) {
-		const abs = resolve(path);
-		let resolvedPath;
+	const graph = new Graph();
+	const source = graph.kind("source");
+	const collect = graph.kind("collect");
+	const plan = graph.kind("plan");
+	const output = graph.kind("output");
+	const finalize = graph.kind("finalize");
+	const processed = graph.each(source, "process", async (node, contents) => {
+		if (contents === void 0) return;
+		const path = node.key;
+		let emitted;
+		const args = {
+			entrypoint: node.scope.name,
+			path,
+			contents,
+			emit(translations) {
+				emitted ??= {
+					path,
+					translations: []
+				};
+				emitted.translations.push(...translations);
+			}
+		};
 		try {
-			resolvedPath = realpathSync(abs);
-		} catch {
-			resolvedPath = abs;
+			for (const { filter, hook } of processors) {
+				if (!filter.test(path)) continue;
+				if (await hook(args) !== void 0) break;
+			}
+		} catch (error) {
+			fail(node.scope.name, path, error);
+			return;
 		}
-		if (paths.has(resolvedPath)) return;
-		logger?.debug({
-			entrypoint: entrypoint.entrypoint,
-			path: resolvedPath
-		}, "resolved path");
-		paths.add(resolvedPath);
-		resolve$1({
-			entrypoint: resolvedPath,
-			path: resolvedPath,
-			namespace: "source"
-		});
-	}
-	function resolve$1(args) {
-		const { entrypoint, path, namespace } = args;
-		const key = `${entrypoint}:${namespace}:${path}`;
-		const visited = resolved.has(key);
-		const skipped = isExcluded(args, context.config.exclude);
-		logger?.debug({
-			entrypoint,
+		return emitted;
+	});
+	function addSource(scope, path, importReference) {
+		if (scope.get(source, path)) return;
+		const args = {
+			entrypoint: scope.name,
 			path,
-			namespace,
-			skipped,
-			visited
-		}, "resolve");
-		if (namespace === "source" && visited) return;
-		resolved.add(key);
-		if (skipped) return;
-		queue.push({
-			type: "resolve",
-			args
-		});
-		getDeferred(namespace).enqueue();
-	}
-	function load(args) {
-		const { entrypoint, path, namespace } = args;
+			namespace: "source",
+			import: importReference
+		};
+		if (isExcluded(args, context.config.exclude)) {
+			logger?.debug(args, "excluded");
+			return;
+		}
 		logger?.debug({
-			entrypoint,
-			path,
-			namespace
-		}, "load");
-		queue.push({
-			type: "load",
-			args
+			entrypoint: scope.name,
+			path
+		}, "source");
+		scope.add(source, path, async () => {
+			try {
+				for (const { filter, hook } of loaders) {
+					if (!filter.test(path)) continue;
+					const contents = await hook({
+						entrypoint: scope.name,
+						path
+					});
+					if (contents !== void 0) return contents;
+				}
+			} catch (error) {
+				fail(scope.name, path, error);
+			}
 		});
-		getDeferred(namespace).enqueue();
 	}
-	function process(args) {
-		const { entrypoint, path, namespace } = args;
-		logger?.debug({
-			entrypoint,
-			path,
-			namespace
-		}, "process");
-		queue.push({
-			type: "process",
-			args
+	function pipeline(path) {
+		if (context.paths.has(path)) return;
+		context.paths.add(path);
+		const scope = graph.scope(path);
+		addSource(scope, path);
+		const collected = scope.completion(processed);
+		collectors.forEach((hook, index) => {
+			scope.add(collect, String(index), {
+				dependencies: [collected],
+				run: async (_node, files) => {
+					if (failed.has(path)) {
+						logger?.warn({ entrypoint: path }, "skipping outputs: entrypoint failed");
+						return [];
+					}
+					const contributions = [];
+					try {
+						await hook({
+							entrypoint: path,
+							files: files.filter((file) => file !== void 0),
+							output: (outputPath, produce) => {
+								contributions.push({
+									path: outputPath,
+									produce
+								});
+							}
+						});
+					} catch (error) {
+						fail(path, path, error);
+						return [];
+					}
+					return contributions;
+				}
+			});
 		});
-		getDeferred(namespace).enqueue();
 	}
 	const build = {
 		context,
-		source,
-		resolve: resolve$1,
-		load,
-		process,
-		defer,
-		onResolve(filter, hook) {
-			resolvers.push({
-				filter,
-				hook
-			});
+		source({ entrypoint: sourceEntrypoint, path, import: importReference }) {
+			if (sourceEntrypoint === path) {
+				pipeline(toRealPath(path));
+				return;
+			}
+			addSource(graph.scope(sourceEntrypoint), path, importReference);
 		},
 		onLoad(filter, hook) {
 			loaders.push({
@@ -1440,6 +1922,12 @@ async function run(entrypoint, { config, logger }) {
 				filter,
 				hook
 			});
+		},
+		onCollected(hook) {
+			collectors.push(hook);
+		},
+		onOutputs(hook) {
+			finalizers.push(hook);
 		}
 	};
 	for (const item of config.plugins) {
@@ -1447,44 +1935,51 @@ async function run(entrypoint, { config, logger }) {
 		logger?.debug({ plugin: plugin.name }, "setting up plugin");
 		plugin.setup(build);
 	}
-	for (const path of await getPaths(entrypoint)) source(path);
-	async function processTask(task) {
-		const { type } = task;
-		let args = task.args;
-		const { entrypoint, path, namespace } = args;
-		logger?.trace({
-			type,
-			entrypoint,
-			path,
-			namespace
-		}, "processing task");
-		for (const { filter, hook } of hooks[type]) {
-			if (filter.namespace !== namespace) continue;
-			if (filter.filter && !filter.filter.test(path)) continue;
-			const result = await hook(args);
-			if (result !== void 0) {
-				args = result;
-				break;
+	const contributed = graph.root.completion(collect);
+	graph.root.add(plan, "outputs", {
+		dependencies: [contributed],
+		run: (_node, collections) => {
+			const byPath = /* @__PURE__ */ new Map();
+			for (const contribution of collections.flat()) {
+				const group = byPath.get(contribution.path) ?? [];
+				group.push(contribution);
+				byPath.set(contribution.path, group);
 			}
+			for (const [outputPath, contributions] of byPath) graph.root.add(output, outputPath, {
+				dependencies: [contributed],
+				run: async () => {
+					try {
+						for (const { produce } of contributions) await produce();
+					} catch (error) {
+						record({ output: outputPath }, error);
+						return;
+					}
+					return outputPath;
+				}
+			});
 		}
-		if (args !== void 0) {
-			if (type === "resolve") load(args);
-			else if (type === "load") process(args);
-		}
-		getDeferred(namespace).dequeue();
-	}
-	while (queue.length || Array.from(pending.values()).some((d) => d.pending > 0)) {
-		while (queue.length) {
-			const task = queue.shift();
-			if (!task) break;
-			await processTask(task);
-		}
-		await Promise.all(Array.from(pending.values()).map((d) => d.promise));
-		await Promise.resolve();
-	}
+	});
+	const outputs = graph.root.completion(output);
+	finalizers.forEach((hook, index) => {
+		graph.root.add(finalize, String(index), {
+			dependencies: [outputs],
+			run: async (_node, produced) => {
+				try {
+					await hook({ outputs: produced.filter((path) => path !== void 0) });
+				} catch (error) {
+					record({ finalizer: String(index) }, error);
+				}
+			}
+		});
+	});
+	for (const path of await getPaths(entrypoint)) pipeline(toRealPath(path));
+	await graph.run().catch((error) => {
+		record({ graph: "run" }, error);
+	});
+	if (failures.length > 0) throw new AggregateError(failures, `Extraction of "${entrypoint.entrypoint}" failed`);
 	logger?.info(entrypoint, "extraction completed");
 }
 //#endregion
 export { cleanup as a, core as i, react as n, po as r, run as t };
 
-//# sourceMappingURL=run-Bv3fv1N8.mjs.map
+//# sourceMappingURL=run-CzeTVOug.mjs.map