@optique/core 1.0.0-dev.1776 → 1.0.0-dev.1785

package/dist/constructs.js

@@ -5,6 +5,7 @@ import { validateLabel } from "./validate.js";
 import { extractArgumentMetavars, extractCommandNames, extractOptionNames, isDocHidden, mergeHidden } from "./usage.js";
 import { deduplicateDocFragments } from "./doc.js";
 import { dispatchByMode, dispatchIterableByMode } from "./mode-dispatch.js";
+import { completeOrExtractPhase2Seed, extractPhase2Seed, extractPhase2SeedKey, phase2SeedFromValueResult } from "./phase2-seed.js";
 import { DEFAULT_FIND_SIMILAR_OPTIONS, createErrorWithSuggestions, createSuggestionMessage, deduplicateSuggestions, findSimilar } from "./suggestion.js";
 import { collectLeadingCandidates } from "./usage-internals.js";
 import { defineInheritedAnnotationParser, getParserSuggestRuntimeNodes, inheritParentAnnotationsKey, unmatchedNonCliDependencySourceStateMarker } from "./parser.js";
@@ -26,6 +27,21 @@ function withChildExecPath(exec, segment) {
 		path: [...exec.path ?? [], segment]
 	};
 }
+function withDependencyRuntimeExec(usage, exec, runtime) {
+	if (exec == null) return {
+		usage,
+		phase: "complete",
+		path: [],
+		trace: void 0,
+		dependencyRuntime: runtime,
+		dependencyRegistry: runtime.registry
+	};
+	return {
+		...exec,
+		dependencyRuntime: runtime,
+		dependencyRegistry: runtime.registry
+	};
+}
 function mergeChildExec(parent, child) {
 	if (parent == null) return child;
 	if (child == null) return parent;
@@ -199,6 +215,69 @@ function unwrapCompleteResult(result) {
 		value
 	};
 }
+function reusePreCompletedPhase2Seed(parser, state, preCompletedResult, exec) {
+	const result = unwrapCompleteResult(preCompletedResult);
+	return result.success ? phase2SeedFromValueResult(result) : extractPhase2Seed(parser, state, exec);
+}
+async function reusePreCompletedPhase2SeedAsync(parser, state, preCompletedResult, exec) {
+	const result = unwrapCompleteResult(preCompletedResult);
+	return result.success ? phase2SeedFromValueResult(result) : await extractPhase2Seed(parser, state, exec);
+}
+function extractOrCompletePhase2SeedSync(parser, state, exec) {
+	const extracted = extractPhase2Seed(parser, state, exec);
+	if (extracted != null) return extracted;
+	const result = parser.complete(state, exec);
+	return result.success ? phase2SeedFromValueResult(result) : null;
+}
+async function extractOrCompletePhase2SeedAsync(parser, state, exec) {
+	const extracted = await extractPhase2Seed(parser, state, exec);
+	if (extracted != null) return extracted;
+	const result = await parser.complete(state, exec);
+	return result.success ? phase2SeedFromValueResult(result) : null;
+}
+function appendFlattenedPhase2Seed(results, deferredKeys, seed) {
+	const baseIndex = results.length;
+	if (Array.isArray(seed.value)) {
+		results.push(...seed.value);
+		if (seed.deferred && seed.deferredKeys) {
+			for (const [key, value] of seed.deferredKeys) {
+				const numKey = typeof key === "string" ? Number(key) : key;
+				if (typeof numKey === "number" && Number.isInteger(numKey)) deferredKeys.set(baseIndex + numKey, value);
+				else deferredKeys.set(key, value);
+			}
+			return false;
+		}
+		return seed.deferred === true;
+	}
+	results.push(seed.value);
+	if (seed.deferred && seed.deferredKeys) {
+		deferredKeys.set(baseIndex, seed.deferredKeys);
+		return false;
+	}
+	if (seed.deferred && (seed.value == null || typeof seed.value !== "object")) {
+		deferredKeys.set(baseIndex, null);
+		return false;
+	}
+	return seed.deferred === true;
+}
+function combineTuplePhase2Seeds(first, second) {
+	if (first == null && second == null) return null;
+	const deferredKeys = /* @__PURE__ */ new Map();
+	let hasDeferred = false;
+	if (first?.deferred) if (first.deferredKeys) deferredKeys.set(0, first.deferredKeys);
+	else if (first.value == null || typeof first.value !== "object") deferredKeys.set(0, null);
+	else hasDeferred = true;
+	if (second?.deferred) if (second.deferredKeys) deferredKeys.set(1, second.deferredKeys);
+	else if (second.value == null || typeof second.value !== "object") deferredKeys.set(1, null);
+	else hasDeferred = true;
+	return {
+		value: [first?.value, second?.value],
+		...deferredKeys.size > 0 || hasDeferred ? {
+			deferred: true,
+			...deferredKeys.size > 0 ? { deferredKeys } : {}
+		} : {}
+	};
+}
 /**
 * Prepares a field state for completion by wrapping `undefined` state
 * with the parser's initial pending dependency state when needed.
@@ -513,70 +592,22 @@ function createExclusiveComplete(parsers, options, noMatchContext, mode) {
 	return (state, exec) => {
 		const activeState = normalizeExclusiveState(state);
 		if (activeState == null) return dispatchByMode(mode, () => {
-			const emptyCtx = {
-				buffer: [],
-				optionsTerminated: false,
-				usage: [],
-				exec,
-				dependencyRegistry: exec?.dependencyRegistry
-			};
-			let candidateIndex = -1;
-			let candidateCount = 0;
-			let candidateParseResult;
-			for (let i$1 = 0; i$1 < syncParsers.length; i$1++) {
-				const p = syncParsers[i$1];
-				if (p.leadingNames.size > 0 || p.acceptingAnyToken) continue;
-				const parseResult = p.parse({
-					...emptyCtx,
-					state: getAnnotatedChildState(state, p.initialState, p)
-				});
-				if (!parseResult.success || parseResult.provisional) continue;
-				candidateCount++;
-				if (candidateIndex < 0) {
-					candidateIndex = i$1;
-					candidateParseResult = parseResult;
-				}
-				if (candidateCount > 1) break;
-			}
-			if (candidateCount === 1 && candidateIndex >= 0 && candidateParseResult) {
-				const p = syncParsers[candidateIndex];
-				const annotatedState = getAnnotatedChildState(state, candidateParseResult.next.state, p);
-				return p.complete(annotatedState, withChildExecPath(exec, candidateIndex));
+			const candidate = findExclusiveZeroInputCandidateSync(syncParsers, state, exec);
+			if (candidate != null) {
+				const p = syncParsers[candidate.index];
+				const annotatedState = getAnnotatedChildState(state, candidate.parseResult.next.state, p);
+				return p.complete(annotatedState, withChildExecPath(exec, candidate.index));
 			}
 			return {
 				success: false,
 				error: getNoMatchError(options, noMatchContext)
 			};
 		}, async () => {
-			const emptyCtx = {
-				buffer: [],
-				optionsTerminated: false,
-				usage: [],
-				exec,
-				dependencyRegistry: exec?.dependencyRegistry
-			};
-			let candidateIndex = -1;
-			let candidateCount = 0;
-			let candidateParseResult;
-			for (let i$1 = 0; i$1 < parsers.length; i$1++) {
-				const p = parsers[i$1];
-				if (p.leadingNames.size > 0 || p.acceptingAnyToken) continue;
-				const parseResult = await p.parse({
-					...emptyCtx,
-					state: getAnnotatedChildState(state, p.initialState, p)
-				});
-				if (!parseResult.success || parseResult.provisional) continue;
-				candidateCount++;
-				if (candidateIndex < 0) {
-					candidateIndex = i$1;
-					candidateParseResult = parseResult;
-				}
-				if (candidateCount > 1) break;
-			}
-			if (candidateCount === 1 && candidateIndex >= 0 && candidateParseResult && (parsers[candidateIndex].$mode === "sync" || exec?.phase !== "parse" && exec?.phase !== "suggest")) {
-				const p = parsers[candidateIndex];
-				const annotatedState = getAnnotatedChildState(state, candidateParseResult.next.state, p);
-				return await p.complete(annotatedState, withChildExecPath(exec, candidateIndex));
+			const candidate = await findExclusiveZeroInputCandidateAsync(parsers, state, exec);
+			if (candidate != null && (parsers[candidate.index].$mode === "sync" || exec?.phase !== "parse" && exec?.phase !== "suggest")) {
+				const p = parsers[candidate.index];
+				const annotatedState = getAnnotatedChildState(state, candidate.parseResult.next.state, p);
+				return await p.complete(annotatedState, withChildExecPath(exec, candidate.index));
 			}
 			return {
 				success: false,
@@ -648,6 +679,83 @@ function getExclusiveSuggestRuntimeNodes(parsers, state, path) {
 	const parser = parsers[index];
 	return getParserSuggestRuntimeNodes(parser, parserResult.next.state, [...path, index]);
 }
+function findExclusiveZeroInputCandidateSync(parsers, state, exec) {
+	const emptyCtx = {
+		buffer: [],
+		optionsTerminated: false,
+		usage: [],
+		exec,
+		dependencyRegistry: exec?.dependencyRegistry
+	};
+	let candidateIndex = -1;
+	let candidateCount = 0;
+	let candidateParseResult;
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		if (parser.leadingNames.size > 0 || parser.acceptingAnyToken) continue;
+		const parseResult = parser.parse({
+			...emptyCtx,
+			state: getAnnotatedChildState(state, parser.initialState, parser)
+		});
+		if (!parseResult.success || parseResult.provisional) continue;
+		candidateCount++;
+		if (candidateIndex < 0) {
+			candidateIndex = i;
+			candidateParseResult = parseResult;
+		}
+		if (candidateCount > 1) break;
+	}
+	return candidateCount === 1 && candidateIndex >= 0 && candidateParseResult != null ? {
+		index: candidateIndex,
+		parseResult: candidateParseResult
+	} : null;
+}
+async function findExclusiveZeroInputCandidateAsync(parsers, state, exec) {
+	const emptyCtx = {
+		buffer: [],
+		optionsTerminated: false,
+		usage: [],
+		exec,
+		dependencyRegistry: exec?.dependencyRegistry
+	};
+	let candidateIndex = -1;
+	let candidateCount = 0;
+	let candidateParseResult;
+	for (let i = 0; i < parsers.length; i++) {
+		const parser = parsers[i];
+		if (parser.leadingNames.size > 0 || parser.acceptingAnyToken) continue;
+		const parseResult = await parser.parse({
+			...emptyCtx,
+			state: getAnnotatedChildState(state, parser.initialState, parser)
+		});
+		if (!parseResult.success || parseResult.provisional) continue;
+		candidateCount++;
+		if (candidateIndex < 0) {
+			candidateIndex = i;
+			candidateParseResult = parseResult;
+		}
+		if (candidateCount > 1) break;
+	}
+	return candidateCount === 1 && candidateIndex >= 0 && candidateParseResult != null ? {
+		index: candidateIndex,
+		parseResult: candidateParseResult
+	} : null;
+}
+function extractExclusivePhase2Seed(parsers, state, exec, mode) {
+	const activeState = normalizeExclusiveState(state);
+	if (activeState == null) return dispatchByMode(mode, () => {
+		const candidate = findExclusiveZeroInputCandidateSync(parsers, state, exec);
+		if (candidate == null) return null;
+		return extractOrCompletePhase2SeedSync(parsers[candidate.index], candidate.parseResult.next.state, withChildExecPath(exec, candidate.index));
+	}, async () => {
+		const candidate = await findExclusiveZeroInputCandidateAsync(parsers, state, exec);
+		if (candidate == null) return null;
+		return await extractOrCompletePhase2SeedAsync(parsers[candidate.index], candidate.parseResult.next.state, withChildExecPath(exec, candidate.index));
+	});
+	if (!activeState[1].success) return dispatchByMode(mode, () => null, () => Promise.resolve(null));
+	const [index, parserResult] = activeState;
+	return completeOrExtractPhase2Seed(parsers[index], parserResult.next.state, withChildExecPath(exec, index));
+}
 /**
 * Gets the no-match error, either from custom options or default.
 * Shared by or() and longestMatch().
@@ -1112,6 +1220,9 @@ function or(...args) {
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState: void 0,
 		complete: createExclusiveComplete(parsers, options, noMatchContext, combinedMode),
+		[extractPhase2SeedKey](state, exec) {
+			return extractExclusivePhase2Seed(parsers, state, exec, combinedMode);
+		},
 		parse(context) {
 			return dispatchByMode(combinedMode, () => parseSync(context), () => parseAsync(context));
 		},
@@ -1272,6 +1383,9 @@ function longestMatch(...args) {
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState: void 0,
 		complete: createExclusiveComplete(parsers, options, noMatchContext, combinedMode),
+		[extractPhase2SeedKey](state, exec) {
+			return extractExclusivePhase2Seed(parsers, state, exec, combinedMode);
+		},
 		parse(context) {
 			return dispatchByMode(combinedMode, () => parseSync(context), () => parseAsync(context));
 		},
@@ -2072,6 +2186,95 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			});
 		},
+		[extractPhase2SeedKey](state, exec) {
+			return dispatchByMode(combinedMode, () => {
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(objectParser.usage, exec, runtime);
+				const typedParserPairs = filterExcludedFieldParsers(parserPairs, exec?.excludedSourceFields);
+				const preCompleted = preCompleteAndRegisterDependencies(state, typedParserPairs, runtime.registry, childExec);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const getFieldState = createFieldStateGetter(state);
+				const annotatedState = {};
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldParser = parsers[field];
+					annotatedState[fieldKey] = getFieldState(field, fieldParser);
+				}
+				collectExplicitSourceValues(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromPairs(typedParserPairs, annotatedState, exec?.path), new Set(preCompleted.keys())), runtime);
+				const resolvedFieldStates = resolveStateWithRuntime(annotatedState, runtime);
+				const result = {};
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldParser = parsers[field];
+					const childExec$1 = withChildExecPath(phase3Exec, fieldKey);
+					const preCompletedResult = preCompleted.get(fieldKey);
+					const seed = preCompletedResult !== void 0 ? reusePreCompletedPhase2Seed(fieldParser, resolvedFieldStates[fieldKey], preCompletedResult, childExec$1) : completeOrExtractPhase2Seed(fieldParser, resolvedFieldStates[fieldKey], childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					result[fieldKey] = seed.value;
+					if (seed.deferred) if (seed.deferredKeys) deferredKeys.set(fieldKey, seed.deferredKeys);
+					else if (seed.value == null || typeof seed.value !== "object") deferredKeys.set(fieldKey, null);
+					else hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: result,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			}, async () => {
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(objectParser.usage, exec, runtime);
+				const asyncParserPairs = filterExcludedFieldParsers(parserPairs, exec?.excludedSourceFields);
+				const preCompleted = await preCompleteAndRegisterDependenciesAsync(state, asyncParserPairs, runtime.registry, childExec);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const getFieldState = createFieldStateGetter(state);
+				const annotatedState = {};
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldParser = parsers[field];
+					annotatedState[fieldKey] = getFieldState(field, fieldParser);
+				}
+				await collectExplicitSourceValuesAsync(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromPairs(asyncParserPairs, annotatedState, exec?.path), new Set(preCompleted.keys())), runtime);
+				const resolvedFieldStates = await resolveStateWithRuntimeAsync(annotatedState, runtime);
+				const result = {};
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldParser = parsers[field];
+					const childExec$1 = withChildExecPath(phase3Exec, fieldKey);
+					const preCompletedResult = preCompleted.get(fieldKey);
+					const seed = preCompletedResult !== void 0 ? await reusePreCompletedPhase2SeedAsync(fieldParser, resolvedFieldStates[fieldKey], preCompletedResult, childExec$1) : await completeOrExtractPhase2Seed(fieldParser, resolvedFieldStates[fieldKey], childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					result[fieldKey] = seed.value;
+					if (seed.deferred) if (seed.deferredKeys) deferredKeys.set(fieldKey, seed.deferredKeys);
+					else if (seed.value == null || typeof seed.value !== "object") deferredKeys.set(fieldKey, null);
+					else hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: result,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			});
+		},
 		suggest(context, prefix) {
 			if (options.hidden === true) return dispatchIterableByMode(combinedMode, function* () {}, async function* () {});
 			return dispatchIterableByMode(combinedMode, () => {
@@ -2624,6 +2827,83 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			});
 		},
+		[extractPhase2SeedKey](state, exec) {
+			return dispatchByMode(combinedMode, () => {
+				const stateArray = state;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(tupleParser.usage, exec, runtime);
+				const tuplePairs = buildIndexedParserPairs(syncParsers);
+				const tupleState = createAnnotatedArrayStateRecord(stateArray);
+				const preCompleted = preCompleteAndRegisterDependencies(tupleState, tuplePairs, runtime.registry, childExec);
+				collectExplicitSourceValues(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(syncParsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = resolveStateWithRuntime(stateArray, runtime);
+				const result = [];
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < syncParsers.length; i++) {
+					const elementParser = syncParsers[i];
+					const childExec$1 = withChildExecPath(phase3Exec, i);
+					const preCompletedResult = preCompleted.get(String(i));
+					const seed = preCompletedResult !== void 0 ? reusePreCompletedPhase2Seed(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), preCompletedResult, childExec$1) : completeOrExtractPhase2Seed(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					result[i] = seed.value;
+					if (seed.deferred) if (seed.deferredKeys) deferredKeys.set(i, seed.deferredKeys);
+					else if (seed.value == null || typeof seed.value !== "object") deferredKeys.set(i, null);
+					else hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: result,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			}, async () => {
+				const stateArray = state;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(tupleParser.usage, exec, runtime);
+				const tuplePairs = buildIndexedParserPairs(parsers);
+				const tupleState = createAnnotatedArrayStateRecord(stateArray);
+				const preCompleted = await preCompleteAndRegisterDependenciesAsync(tupleState, tuplePairs, runtime.registry, childExec);
+				await collectExplicitSourceValuesAsync(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(parsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = await resolveStateWithRuntimeAsync(stateArray, runtime);
+				const result = [];
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < parsers.length; i++) {
+					const elementParser = parsers[i];
+					const childExec$1 = withChildExecPath(phase3Exec, i);
+					const preCompletedResult = preCompleted.get(String(i));
+					const seed = preCompletedResult !== void 0 ? await reusePreCompletedPhase2SeedAsync(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), preCompletedResult, childExec$1) : await completeOrExtractPhase2Seed(elementParser, prepareStateForCompletion(resolvedArray[i], elementParser), childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					result[i] = seed.value;
+					if (seed.deferred) if (seed.deferredKeys) deferredKeys.set(i, seed.deferredKeys);
+					else if (seed.value == null || typeof seed.value !== "object") deferredKeys.set(i, null);
+					else hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: result,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			});
+		},
 		suggest(context, prefix) {
 			return dispatchIterableByMode(combinedMode, () => suggestTupleSync(context, prefix, syncParsers), () => suggestTupleAsync(context, prefix, parsers));
 		},
@@ -3015,6 +3295,153 @@ function merge(...args) {
 				};
 			})();
 		},
+		[extractPhase2SeedKey](state, exec) {
+			const extractMergeCompleteState = (parser, resolvedState, index) => {
+				if (parser.initialState === void 0) {
+					const key = parserStateKey(index);
+					if (resolvedState && typeof resolvedState === "object" && key in resolvedState) return resolvedState[key];
+					return void 0;
+				} else if (parser.initialState && typeof parser.initialState === "object") {
+					const key = localObjectStateKey(index);
+					if (shouldPreserveLocalChildState(parser) && resolvedState && typeof resolvedState === "object" && key in resolvedState) return resolvedState[key];
+					if (resolvedState && typeof resolvedState === "object") {
+						const extractedState = {};
+						for (const field in parser.initialState) extractedState[field] = field in resolvedState ? resolvedState[field] : parser.initialState[field];
+						return inheritAnnotations(resolvedState, extractedState);
+					}
+					return parser.initialState;
+				}
+				return parser.initialState;
+			};
+			return dispatchByMode(combinedMode, () => {
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(mergeParser.usage, exec, runtime);
+				const duplicateFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
+				const unambiguousFieldParsers = filterDuplicateFieldParsers(mergedFieldParsers);
+				const perChildPhase1 = syncParsers.map((parser, i) => {
+					if (fieldParsersKey in parser) {
+						const pairs = parser[fieldParsersKey];
+						const excludedSourceFields = new Set(pairs.map(([field]) => field).filter((field) => duplicateFieldNames.has(field)));
+						const phase1Pairs = filterExcludedFieldParsers(pairs, excludedSourceFields);
+						const preCompleted = preCompleteAndRegisterDependencies(state, phase1Pairs, runtime.registry, withChildExecPath(childExec, i));
+						return {
+							cache: filterDuplicateKeys(preCompleted, phase1Pairs),
+							excludedSourceFields: excludedSourceFields.size > 0 ? excludedSourceFields : void 0
+						};
+					}
+					return {
+						cache: void 0,
+						excludedSourceFields: void 0
+					};
+				});
+				collectExplicitSourceValues(buildRuntimeNodesFromPairs(unambiguousFieldParsers, state, exec?.path), runtime);
+				const resolvedState = resolveStateWithRuntime(state, runtime);
+				const object$1 = {};
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < syncParsers.length; i++) {
+					const parser = syncParsers[i];
+					const parserState = extractMergeCompleteState(parser, resolvedState, i);
+					const { cache, excludedSourceFields } = perChildPhase1[i];
+					const childCompleteExec = withChildExecPath(childExec, i);
+					const completeExec = excludedSourceFields == null ? {
+						...childCompleteExec,
+						preCompletedByParser: cache
+					} : (() => {
+						const childRuntime = createDependencyRuntimeContext(runtime.registry.clone());
+						return {
+							...childCompleteExec,
+							dependencyRuntime: childRuntime,
+							dependencyRegistry: childRuntime.registry,
+							preCompletedByParser: cache
+						};
+					})();
+					const seed = completeOrExtractPhase2Seed(parser, parserState, completeExec);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					const seedValue = seed.value;
+					for (const field in seedValue) {
+						object$1[field] = seedValue[field];
+						if (deferredKeys.has(field) && !(seed.deferred && seed.deferredKeys?.has(field))) deferredKeys.delete(field);
+					}
+					if (seed.deferred && seed.deferredKeys) for (const [key, value] of seed.deferredKeys) deferredKeys.set(key, value);
+					else if (seed.deferred) hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: object$1,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			}, async () => {
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(mergeParser.usage, exec, runtime);
+				const duplicateFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
+				const unambiguousFieldParsers = filterDuplicateFieldParsers(mergedFieldParsers);
+				const perChildPhase1 = [];
+				for (let i = 0; i < parsers.length; i++) {
+					const parser = parsers[i];
+					if (fieldParsersKey in parser) {
+						const pairs = parser[fieldParsersKey];
+						const excludedSourceFields = new Set(pairs.map(([field]) => field).filter((field) => duplicateFieldNames.has(field)));
+						const phase1Pairs = filterExcludedFieldParsers(pairs, excludedSourceFields);
+						const preCompleted = await preCompleteAndRegisterDependenciesAsync(state, phase1Pairs, runtime.registry, withChildExecPath(childExec, i));
+						perChildPhase1.push({
+							cache: filterDuplicateKeys(preCompleted, phase1Pairs),
+							excludedSourceFields: excludedSourceFields.size > 0 ? excludedSourceFields : void 0
+						});
+					} else perChildPhase1.push({
+						cache: void 0,
+						excludedSourceFields: void 0
+					});
+				}
+				await collectExplicitSourceValuesAsync(buildRuntimeNodesFromPairs(unambiguousFieldParsers, state, exec?.path), runtime);
+				const resolvedState = await resolveStateWithRuntimeAsync(state, runtime);
+				const object$1 = {};
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < parsers.length; i++) {
+					const parser = parsers[i];
+					const parserState = extractMergeCompleteState(parser, resolvedState, i);
+					const { cache: asyncCache, excludedSourceFields } = perChildPhase1[i];
+					const childCompleteExec = withChildExecPath(childExec, i);
+					const completeExec = excludedSourceFields == null ? {
+						...childCompleteExec,
+						preCompletedByParser: asyncCache
+					} : (() => {
+						const childRuntime = createDependencyRuntimeContext(runtime.registry.clone());
+						return {
+							...childCompleteExec,
+							dependencyRuntime: childRuntime,
+							dependencyRegistry: childRuntime.registry,
+							preCompletedByParser: asyncCache
+						};
+					})();
+					const seed = await completeOrExtractPhase2Seed(parser, parserState, completeExec);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					const seedValue = seed.value;
+					for (const field in seedValue) {
+						object$1[field] = seedValue[field];
+						if (deferredKeys.has(field) && !(seed.deferred && seed.deferredKeys?.has(field))) deferredKeys.delete(field);
+					}
+					if (seed.deferred && seed.deferredKeys) for (const [key, value] of seed.deferredKeys) deferredKeys.set(key, value);
+					else if (seed.deferred) hasDeferred = true;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: object$1,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			});
+		},
 		suggest(context, prefix) {
 			if (options.hidden === true) return dispatchIterableByMode(combinedMode, function* () {}, async function* () {});
 			const extractState = (p, i) => {
@@ -3663,6 +4090,77 @@ function concat(...parsers) {
 			if (isAsync) return completeAsync(state, exec);
 			return completeSync(state, exec);
 		},
+		[extractPhase2SeedKey](state, exec) {
+			return dispatchByMode(combinedMode, () => {
+				const stateArray = state;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(concatParser.usage, exec, runtime);
+				const concatPairs = buildIndexedParserPairs(syncParsers);
+				const concatState = createAnnotatedArrayStateRecord(stateArray);
+				const preCompleted = preCompleteAndRegisterDependencies(concatState, concatPairs, runtime.registry, childExec);
+				collectExplicitSourceValues(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(syncParsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = resolveStateWithRuntime(stateArray, runtime);
+				const results = [];
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < syncParsers.length; i++) {
+					const parser = syncParsers[i];
+					const childExec$1 = withChildExecPath(phase3Exec, i);
+					const preCompletedResult = preCompleted.get(String(i));
+					const seed = preCompletedResult !== void 0 ? reusePreCompletedPhase2Seed(parser, prepareStateForCompletion(resolvedArray[i], parser), preCompletedResult, childExec$1) : completeOrExtractPhase2Seed(parser, prepareStateForCompletion(resolvedArray[i], parser), childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					hasDeferred = appendFlattenedPhase2Seed(results, deferredKeys, seed) || hasDeferred;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: results,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			}, async () => {
+				const stateArray = state;
+				const runtime = exec?.dependencyRuntime ?? createDependencyRuntimeContext(exec?.dependencyRegistry);
+				const childExec = withDependencyRuntimeExec(concatParser.usage, exec, runtime);
+				const concatPairs = buildIndexedParserPairs(parsers);
+				const concatState = createAnnotatedArrayStateRecord(stateArray);
+				const preCompleted = await preCompleteAndRegisterDependenciesAsync(concatState, concatPairs, runtime.registry, childExec);
+				await collectExplicitSourceValuesAsync(filterPreCompletedRuntimeNodes(buildRuntimeNodesFromArray(parsers, stateArray, exec?.path), new Set(preCompleted.keys())), runtime);
+				const phase3Exec = {
+					...childExec,
+					preCompletedByParser: void 0
+				};
+				const resolvedArray = await resolveStateWithRuntimeAsync(stateArray, runtime);
+				const results = [];
+				const deferredKeys = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				let hasAnySeed = false;
+				for (let i = 0; i < parsers.length; i++) {
+					const parser = parsers[i];
+					const childExec$1 = withChildExecPath(phase3Exec, i);
+					const preCompletedResult = preCompleted.get(String(i));
+					const seed = preCompletedResult !== void 0 ? await reusePreCompletedPhase2SeedAsync(parser, prepareStateForCompletion(resolvedArray[i], parser), preCompletedResult, childExec$1) : await completeOrExtractPhase2Seed(parser, prepareStateForCompletion(resolvedArray[i], parser), childExec$1);
+					if (seed == null) continue;
+					hasAnySeed = true;
+					hasDeferred = appendFlattenedPhase2Seed(results, deferredKeys, seed) || hasDeferred;
+				}
+				if (!hasAnySeed) return null;
+				return {
+					value: results,
+					...deferredKeys.size > 0 || hasDeferred ? {
+						deferred: true,
+						...deferredKeys.size > 0 ? { deferredKeys } : {}
+					} : {}
+				};
+			});
+		},
 		suggest(context, prefix) {
 			if (isAsync) return async function* () {
 				const preParsedContext$1 = await preParseSuggestContextAsync(context, parsers);
@@ -3783,6 +4281,13 @@ function group(label, parser, options = {}) {
 			};
 		}
 	};
+	Object.defineProperty(groupParser, extractPhase2SeedKey, {
+		value(state, exec) {
+			return extractPhase2Seed(parser, state, exec);
+		},
+		configurable: true,
+		enumerable: false
+	});
 	if ("placeholder" in parser) Object.defineProperty(groupParser, "placeholder", {
 		get() {
 			return parser.placeholder;
@@ -4544,6 +5049,16 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			} : {}
 		};
 	};
+	const getConditionalBranchSeedSync = (currentState, branchParser, branchState, exec) => {
+		const branchExec = withChildExecPath(exec, "_branch");
+		const annotatedState = getAnnotatedChildState(currentState, branchState, branchParser);
+		return extractOrCompletePhase2SeedSync(branchParser, annotatedState, branchExec);
+	};
+	const getConditionalBranchSeedAsync = async (currentState, branchParser, branchState, exec) => {
+		const branchExec = withChildExecPath(exec, "_branch");
+		const annotatedState = getAnnotatedChildState(currentState, branchState, branchParser);
+		return await extractOrCompletePhase2SeedAsync(branchParser, annotatedState, branchExec);
+	};
 	function* suggestSync(context, prefix) {
 		const state = context.state ?? initialState;
 		const syncDiscriminator = discriminator;
@@ -4675,6 +5190,54 @@ function conditional(discriminator, branches, defaultBranch, options) {
 			if (isAsync) return completeAsync(state, exec);
 			return completeSync(state, exec);
 		},
+		[extractPhase2SeedKey](state, exec) {
+			return dispatchByMode(combinedMode, () => {
+				const syncDiscriminator = discriminator;
+				const syncDefaultBranch = defaultBranch;
+				const syncBranches = branches;
+				const discriminatorExec = withChildExecPath(exec, "_discriminator");
+				if (state.selectedBranch === void 0) {
+					const discriminatorSeed$1 = completeOrExtractPhase2Seed(syncDiscriminator, getAnnotatedChildState(state, state.discriminatorState, syncDiscriminator), discriminatorExec);
+					if (typeof discriminatorSeed$1?.value === "string") {
+						const branchParser$1 = syncBranches[discriminatorSeed$1.value];
+						if (branchParser$1 != null) {
+							const branchSeed$1 = getConditionalBranchSeedSync(state, branchParser$1, branchParser$1.initialState, exec);
+							return combineTuplePhase2Seeds(discriminatorSeed$1, branchSeed$1);
+						}
+					}
+					if (syncDefaultBranch != null) {
+						const branchSeed$1 = getConditionalBranchSeedSync(state, syncDefaultBranch, state.branchState ?? syncDefaultBranch.initialState, exec);
+						return combineTuplePhase2Seeds(null, branchSeed$1);
+					}
+					return combineTuplePhase2Seeds(discriminatorSeed$1, null);
+				}
+				const branchParser = state.selectedBranch.kind === "default" ? syncDefaultBranch : syncBranches[state.selectedBranch.key];
+				const branchSeed = getConditionalBranchSeedSync(state, branchParser, state.branchState ?? branchParser.initialState, exec);
+				const discriminatorSeed = state.selectedBranch.kind === "default" ? null : state.discriminatorValue != null && state.discriminatorValue === state.selectedBranch.key ? { value: state.discriminatorValue } : completeOrExtractPhase2Seed(syncDiscriminator, getAnnotatedChildState(state, state.discriminatorState, syncDiscriminator), discriminatorExec) ?? { value: state.selectedBranch.key };
+				return combineTuplePhase2Seeds(discriminatorSeed, branchSeed);
+			}, async () => {
+				const discriminatorExec = withChildExecPath(exec, "_discriminator");
+				if (state.selectedBranch === void 0) {
+					const discriminatorSeed$1 = await completeOrExtractPhase2Seed(discriminator, getAnnotatedChildState(state, state.discriminatorState, discriminator), discriminatorExec);
+					if (typeof discriminatorSeed$1?.value === "string") {
+						const branchParser$1 = branches[discriminatorSeed$1.value];
+						if (branchParser$1 != null) {
+							const branchSeed$1 = await getConditionalBranchSeedAsync(state, branchParser$1, branchParser$1.initialState, exec);
+							return combineTuplePhase2Seeds(discriminatorSeed$1, branchSeed$1);
+						}
+					}
+					if (defaultBranch != null) {
+						const branchSeed$1 = await getConditionalBranchSeedAsync(state, defaultBranch, state.branchState ?? defaultBranch.initialState, exec);
+						return combineTuplePhase2Seeds(null, branchSeed$1);
+					}
+					return combineTuplePhase2Seeds(discriminatorSeed$1, null);
+				}
+				const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
+				const branchSeed = await getConditionalBranchSeedAsync(state, branchParser, state.branchState ?? branchParser.initialState, exec);
+				const discriminatorSeed = state.selectedBranch.kind === "default" ? null : state.discriminatorValue != null && state.discriminatorValue === state.selectedBranch.key ? { value: state.discriminatorValue } : await completeOrExtractPhase2Seed(discriminator, getAnnotatedChildState(state, state.discriminatorState, discriminator), discriminatorExec) ?? { value: state.selectedBranch.key };
+				return combineTuplePhase2Seeds(discriminatorSeed, branchSeed);
+			});
+		},
 		suggest(context, prefix) {
 			if (isAsync) return suggestAsync(context, prefix);
 			return suggestSync(context, prefix);