@optique/core 1.0.0-dev.1495 → 1.0.0-dev.1500

package/dist/modifiers.cjs

@@ -2,7 +2,6 @@ const require_annotations = require('./annotations.cjs');
 const require_message = require('./message.cjs');
 const require_dependency = require('./dependency.cjs');
 const require_mode_dispatch = require('./mode-dispatch.cjs');
-const require_context = require('./context.cjs');
 
 //#region src/modifiers.ts
 /**
@@ -123,6 +122,7 @@ function optional(parser) {
 		$mode: parser.$mode,
 		$valueType: [],
 		$stateType: [],
+		placeholder: void 0,
 		priority: parser.priority,
 		usage: [{
 			type: "optional",
@@ -237,7 +237,7 @@ function withDefault(parser, defaultValue, options) {
 	}
 	const innerInitialState = syncParser.initialState;
 	const wrappedDependencyMarker = require_dependency.isPendingDependencySourceState(innerInitialState) ? { [require_dependency.wrappedDependencySourceMarker]: innerInitialState } : require_dependency.isWrappedDependencySource(parser) ? { [require_dependency.wrappedDependencySourceMarker]: parser[require_dependency.wrappedDependencySourceMarker] } : {};
-	return {
+	const withDefaultParser = {
 		$mode: parser.$mode,
 		$valueType: [],
 		$stateType: [],
@@ -386,6 +386,14 @@ function withDefault(parser, defaultValue, options) {
 			return fragments;
 		}
 	};
+	if ("placeholder" in parser) Object.defineProperty(withDefaultParser, "placeholder", {
+		get() {
+			return parser.placeholder;
+		},
+		configurable: true,
+		enumerable: false
+	});
+	return withDefaultParser;
 }
 /**
 * Creates a parser that transforms the result value of another parser using
@@ -406,6 +414,47 @@ function withDefault(parser, defaultValue, options) {
 * @param transform A function that transforms the parsed value from type T to type U.
 * @returns A {@link Parser} that produces the transformed value of type U
 *          while preserving the original parser's state type and parsing behavior.
+* @throws Any exception thrown by `transform` when completing a non-deferred
+*   value.  Errors from deferred placeholder transforms are caught and the
+*   mapped result falls back to `undefined` with `deferred: true`.
+*
+* ### Deferred prompt interaction
+*
+* During two-phase parsing, `map()` propagates the `deferred` flag from
+* inner results but intentionally drops per-field `deferredKeys`.  The
+* inner key set describes the *input* shape, but `transform` produces an
+* arbitrary *output* shape where keys may be renamed, dropped, or reused
+* with different semantics.  For `object()` results that are *not*
+* wrapped in `map()`, per-field deferred stripping works normally.
+*
+* Because the `deferred` flag is propagated conservatively, mapped scalar
+* results are treated as missing (`undefined`) during phase-two context
+* collection — even when `transform` only used non-deferred fields.
+* For example, `map(object({ apiKey: prompt(...), mode: option(...) }),
+* v => v.mode)` makes phase-two contexts see `undefined` instead of the
+* real `mode` value.  This is the intentional trade-off: the alternative
+* (not propagating `deferred`) would leak placeholder values into context
+* resolution when `transform` *does* use deferred fields.  The final
+* parse always produces the correct result regardless.
+*
+* If the transform throws on a deferred placeholder value, the mapped
+* result falls back to `undefined` with `deferred: true`, so the first
+* pass does not abort.
+*
+* ### Transform purity
+*
+* The `transform` function must not mutate its input.  Object and array
+* values may be shared placeholder references during deferred prompt
+* resolution, and in-place mutations would corrupt the placeholder for
+* subsequent parses.  Always return a new value:
+*
+* ```typescript
+* // ✅ Correct — creates a new object
+* map(parser, v => ({ ...v, host: "override" }))
+*
+* // ❌ Wrong — mutates the input in place
+* map(parser, v => { v.host = "override"; return v; })
+* ```
 *
 * @example
 * ```typescript
@@ -423,16 +472,32 @@ function withDefault(parser, defaultValue, options) {
 */
 function map(parser, transform) {
 	const complete = (state) => {
-		return require_mode_dispatch.mapModeValue(parser.$mode, parser.complete(state), (result) => result.success ? require_context.isPlaceholderValue(result.value) ? result : {
-			success: true,
-			value: transform(result.value)
-		} : result);
+		return require_mode_dispatch.mapModeValue(parser.$mode, parser.complete(state), (result) => {
+			if (!result.success) return result;
+			if (result.deferred) try {
+				return {
+					success: true,
+					value: transform(result.value),
+					deferred: true
+				};
+			} catch {
+				return {
+					success: true,
+					value: void 0,
+					deferred: true
+				};
+			}
+			return {
+				success: true,
+				value: transform(result.value)
+			};
+		});
 	};
 	const dependencyMarkers = require_dependency.isWrappedDependencySource(parser) ? {
 		[require_dependency.wrappedDependencySourceMarker]: parser[require_dependency.wrappedDependencySourceMarker],
 		[require_dependency.transformsDependencyValueMarker]: true
 	} : {};
-	return {
+	const mappedParser = {
 		...parser,
 		$valueType: [],
 		complete,
@@ -441,6 +506,18 @@ function map(parser, transform) {
 			return parser.getDocFragments(state, void 0);
 		}
 	};
+	if ("placeholder" in parser) Object.defineProperty(mappedParser, "placeholder", {
+		get() {
+			try {
+				return transform(parser.placeholder);
+			} catch {
+				return void 0;
+			}
+		},
+		configurable: true,
+		enumerable: false
+	});
+	return mappedParser;
 }
 /**
 * Creates a parser that allows multiple occurrences of a given parser.
@@ -580,24 +657,41 @@ function multiple(parser, options = {}) {
 		complete(state) {
 			return require_mode_dispatch.dispatchByMode(parser.$mode, () => {
 				const result = [];
-				for (const s of state) {
-					const valueResult = completeSyncWithUnwrappedFallback(s);
-					if (valueResult.success) result.push(unwrapInjectedWrapper(valueResult.value));
-					else return {
+				const deferredIndices = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				for (let i = 0; i < state.length; i++) {
+					const valueResult = completeSyncWithUnwrappedFallback(state[i]);
+					if (valueResult.success) {
+						const unwrappedValue = unwrapInjectedWrapper(valueResult.value);
+						result.push(unwrappedValue);
+						if (valueResult.deferred) if (valueResult.deferredKeys) deferredIndices.set(i, valueResult.deferredKeys);
+						else if (unwrappedValue == null || typeof unwrappedValue !== "object") deferredIndices.set(i, null);
+						else hasDeferred = true;
+					} else return {
 						success: false,
 						error: valueResult.error
 					};
 				}
-				return validateMultipleResult(result);
+				return validateMultipleResult(result, deferredIndices, hasDeferred);
 			}, async () => {
 				const results = await Promise.all(state.map((s) => completeAsyncWithUnwrappedFallback(s)));
 				const values = [];
-				for (const valueResult of results) if (valueResult.success) values.push(unwrapInjectedWrapper(valueResult.value));
-				else return {
-					success: false,
-					error: valueResult.error
-				};
-				return validateMultipleResult(values);
+				const deferredIndices = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				for (let i = 0; i < results.length; i++) {
+					const valueResult = results[i];
+					if (valueResult.success) {
+						const unwrappedValue = unwrapInjectedWrapper(valueResult.value);
+						values.push(unwrappedValue);
+						if (valueResult.deferred) if (valueResult.deferredKeys) deferredIndices.set(i, valueResult.deferredKeys);
+						else if (unwrappedValue == null || typeof unwrappedValue !== "object") deferredIndices.set(i, null);
+						else hasDeferred = true;
+					} else return {
+						success: false,
+						error: valueResult.error
+					};
+				}
+				return validateMultipleResult(values, deferredIndices, hasDeferred);
 			});
 		},
 		suggest(context, prefix) {
@@ -694,7 +788,7 @@ function multiple(parser, options = {}) {
 			return syncParser.getDocFragments(innerState, defaultValue != null && defaultValue.length > 0 ? defaultValue[0] : void 0);
 		}
 	};
-	function validateMultipleResult(result) {
+	function validateMultipleResult(result, deferredIndices, hasDeferred = false) {
 		if (result.length < min) {
 			const customMessage = options.errors?.tooFew;
 			return {
@@ -708,11 +802,26 @@ function multiple(parser, options = {}) {
 				error: customMessage ? typeof customMessage === "function" ? customMessage(max, result.length) : customMessage : require_message.message`Expected at most ${require_message.text(max.toLocaleString("en"))} values, but got ${require_message.text(result.length.toLocaleString("en"))}.`
 			};
 		}
+		const isDeferred = deferredIndices.size > 0 || hasDeferred;
 		return {
 			success: true,
-			value: result
+			value: result,
+			...isDeferred ? {
+				deferred: true,
+				...deferredIndices.size > 0 ? { deferredKeys: deferredIndices } : {}
+			} : {}
 		};
 	}
+	Object.defineProperty(resultParser, "placeholder", {
+		get() {
+			try {
+				if (min > 0 && "placeholder" in parser) return Array.from({ length: min }, () => parser.placeholder);
+			} catch {}
+			return [];
+		},
+		configurable: true,
+		enumerable: false
+	});
 	return resultParser;
 }
 /**
@@ -771,13 +880,14 @@ function nonEmpty(parser) {
 		const result = await parser.parse(context);
 		return processNonEmptyResult(result);
 	};
-	return {
+	const nonEmptyParser = {
 		$mode: parser.$mode,
 		$valueType: parser.$valueType,
 		$stateType: parser.$stateType,
 		priority: parser.priority,
 		usage: parser.usage,
 		initialState: parser.initialState,
+		...typeof parser.shouldDeferCompletion === "function" ? { shouldDeferCompletion: parser.shouldDeferCompletion.bind(parser) } : {},
 		parse(context) {
 			return require_mode_dispatch.dispatchByMode(parser.$mode, () => parseSync(context), () => parseAsync(context));
 		},
@@ -791,6 +901,14 @@ function nonEmpty(parser) {
 			return syncParser.getDocFragments(state, defaultValue);
 		}
 	};
+	if ("placeholder" in parser) Object.defineProperty(nonEmptyParser, "placeholder", {
+		get() {
+			return parser.placeholder;
+		},
+		configurable: true,
+		enumerable: false
+	});
+	return nonEmptyParser;
 }
 
 //#endregion

package/dist/modifiers.d.cts

@@ -123,6 +123,47 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  * @param transform A function that transforms the parsed value from type T to type U.
  * @returns A {@link Parser} that produces the transformed value of type U
  *          while preserving the original parser's state type and parsing behavior.
+ * @throws Any exception thrown by `transform` when completing a non-deferred
+ *   value.  Errors from deferred placeholder transforms are caught and the
+ *   mapped result falls back to `undefined` with `deferred: true`.
+ *
+ * ### Deferred prompt interaction
+ *
+ * During two-phase parsing, `map()` propagates the `deferred` flag from
+ * inner results but intentionally drops per-field `deferredKeys`.  The
+ * inner key set describes the *input* shape, but `transform` produces an
+ * arbitrary *output* shape where keys may be renamed, dropped, or reused
+ * with different semantics.  For `object()` results that are *not*
+ * wrapped in `map()`, per-field deferred stripping works normally.
+ *
+ * Because the `deferred` flag is propagated conservatively, mapped scalar
+ * results are treated as missing (`undefined`) during phase-two context
+ * collection — even when `transform` only used non-deferred fields.
+ * For example, `map(object({ apiKey: prompt(...), mode: option(...) }),
+ * v => v.mode)` makes phase-two contexts see `undefined` instead of the
+ * real `mode` value.  This is the intentional trade-off: the alternative
+ * (not propagating `deferred`) would leak placeholder values into context
+ * resolution when `transform` *does* use deferred fields.  The final
+ * parse always produces the correct result regardless.
+ *
+ * If the transform throws on a deferred placeholder value, the mapped
+ * result falls back to `undefined` with `deferred: true`, so the first
+ * pass does not abort.
+ *
+ * ### Transform purity
+ *
+ * The `transform` function must not mutate its input.  Object and array
+ * values may be shared placeholder references during deferred prompt
+ * resolution, and in-place mutations would corrupt the placeholder for
+ * subsequent parses.  Always return a new value:
+ *
+ * ```typescript
+ * // ✅ Correct — creates a new object
+ * map(parser, v => ({ ...v, host: "override" }))
+ *
+ * // ❌ Wrong — mutates the input in place
+ * map(parser, v => { v.host = "override"; return v; })
+ * ```
  *
  * @example
  * ```typescript

package/dist/modifiers.d.ts

@@ -123,6 +123,47 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  * @param transform A function that transforms the parsed value from type T to type U.
  * @returns A {@link Parser} that produces the transformed value of type U
  *          while preserving the original parser's state type and parsing behavior.
+ * @throws Any exception thrown by `transform` when completing a non-deferred
+ *   value.  Errors from deferred placeholder transforms are caught and the
+ *   mapped result falls back to `undefined` with `deferred: true`.
+ *
+ * ### Deferred prompt interaction
+ *
+ * During two-phase parsing, `map()` propagates the `deferred` flag from
+ * inner results but intentionally drops per-field `deferredKeys`.  The
+ * inner key set describes the *input* shape, but `transform` produces an
+ * arbitrary *output* shape where keys may be renamed, dropped, or reused
+ * with different semantics.  For `object()` results that are *not*
+ * wrapped in `map()`, per-field deferred stripping works normally.
+ *
+ * Because the `deferred` flag is propagated conservatively, mapped scalar
+ * results are treated as missing (`undefined`) during phase-two context
+ * collection — even when `transform` only used non-deferred fields.
+ * For example, `map(object({ apiKey: prompt(...), mode: option(...) }),
+ * v => v.mode)` makes phase-two contexts see `undefined` instead of the
+ * real `mode` value.  This is the intentional trade-off: the alternative
+ * (not propagating `deferred`) would leak placeholder values into context
+ * resolution when `transform` *does* use deferred fields.  The final
+ * parse always produces the correct result regardless.
+ *
+ * If the transform throws on a deferred placeholder value, the mapped
+ * result falls back to `undefined` with `deferred: true`, so the first
+ * pass does not abort.
+ *
+ * ### Transform purity
+ *
+ * The `transform` function must not mutate its input.  Object and array
+ * values may be shared placeholder references during deferred prompt
+ * resolution, and in-place mutations would corrupt the placeholder for
+ * subsequent parses.  Always return a new value:
+ *
+ * ```typescript
+ * // ✅ Correct — creates a new object
+ * map(parser, v => ({ ...v, host: "override" }))
+ *
+ * // ❌ Wrong — mutates the input in place
+ * map(parser, v => { v.host = "override"; return v; })
+ * ```
  *
  * @example
  * ```typescript

package/dist/modifiers.js

@@ -2,7 +2,6 @@ import { annotateFreshArray, getAnnotations, inheritAnnotations, isInjectedAnnot
 import { formatMessage, message, text } from "./message.js";
 import { createDependencySourceState, dependencyId, isDependencySourceState, isPendingDependencySourceState, isWrappedDependencySource, transformsDependencyValue, transformsDependencyValueMarker, wrappedDependencySourceMarker } from "./dependency.js";
 import { dispatchByMode, dispatchIterableByMode, mapModeValue } from "./mode-dispatch.js";
-import { isPlaceholderValue } from "./context.js";
 
 //#region src/modifiers.ts
 /**
@@ -123,6 +122,7 @@ function optional(parser) {
 		$mode: parser.$mode,
 		$valueType: [],
 		$stateType: [],
+		placeholder: void 0,
 		priority: parser.priority,
 		usage: [{
 			type: "optional",
@@ -237,7 +237,7 @@ function withDefault(parser, defaultValue, options) {
 	}
 	const innerInitialState = syncParser.initialState;
 	const wrappedDependencyMarker = isPendingDependencySourceState(innerInitialState) ? { [wrappedDependencySourceMarker]: innerInitialState } : isWrappedDependencySource(parser) ? { [wrappedDependencySourceMarker]: parser[wrappedDependencySourceMarker] } : {};
-	return {
+	const withDefaultParser = {
 		$mode: parser.$mode,
 		$valueType: [],
 		$stateType: [],
@@ -386,6 +386,14 @@ function withDefault(parser, defaultValue, options) {
 			return fragments;
 		}
 	};
+	if ("placeholder" in parser) Object.defineProperty(withDefaultParser, "placeholder", {
+		get() {
+			return parser.placeholder;
+		},
+		configurable: true,
+		enumerable: false
+	});
+	return withDefaultParser;
 }
 /**
 * Creates a parser that transforms the result value of another parser using
@@ -406,6 +414,47 @@ function withDefault(parser, defaultValue, options) {
 * @param transform A function that transforms the parsed value from type T to type U.
 * @returns A {@link Parser} that produces the transformed value of type U
 *          while preserving the original parser's state type and parsing behavior.
+* @throws Any exception thrown by `transform` when completing a non-deferred
+*   value.  Errors from deferred placeholder transforms are caught and the
+*   mapped result falls back to `undefined` with `deferred: true`.
+*
+* ### Deferred prompt interaction
+*
+* During two-phase parsing, `map()` propagates the `deferred` flag from
+* inner results but intentionally drops per-field `deferredKeys`.  The
+* inner key set describes the *input* shape, but `transform` produces an
+* arbitrary *output* shape where keys may be renamed, dropped, or reused
+* with different semantics.  For `object()` results that are *not*
+* wrapped in `map()`, per-field deferred stripping works normally.
+*
+* Because the `deferred` flag is propagated conservatively, mapped scalar
+* results are treated as missing (`undefined`) during phase-two context
+* collection — even when `transform` only used non-deferred fields.
+* For example, `map(object({ apiKey: prompt(...), mode: option(...) }),
+* v => v.mode)` makes phase-two contexts see `undefined` instead of the
+* real `mode` value.  This is the intentional trade-off: the alternative
+* (not propagating `deferred`) would leak placeholder values into context
+* resolution when `transform` *does* use deferred fields.  The final
+* parse always produces the correct result regardless.
+*
+* If the transform throws on a deferred placeholder value, the mapped
+* result falls back to `undefined` with `deferred: true`, so the first
+* pass does not abort.
+*
+* ### Transform purity
+*
+* The `transform` function must not mutate its input.  Object and array
+* values may be shared placeholder references during deferred prompt
+* resolution, and in-place mutations would corrupt the placeholder for
+* subsequent parses.  Always return a new value:
+*
+* ```typescript
+* // ✅ Correct — creates a new object
+* map(parser, v => ({ ...v, host: "override" }))
+*
+* // ❌ Wrong — mutates the input in place
+* map(parser, v => { v.host = "override"; return v; })
+* ```
 *
 * @example
 * ```typescript
@@ -423,16 +472,32 @@ function withDefault(parser, defaultValue, options) {
 */
 function map(parser, transform) {
 	const complete = (state) => {
-		return mapModeValue(parser.$mode, parser.complete(state), (result) => result.success ? isPlaceholderValue(result.value) ? result : {
-			success: true,
-			value: transform(result.value)
-		} : result);
+		return mapModeValue(parser.$mode, parser.complete(state), (result) => {
+			if (!result.success) return result;
+			if (result.deferred) try {
+				return {
+					success: true,
+					value: transform(result.value),
+					deferred: true
+				};
+			} catch {
+				return {
+					success: true,
+					value: void 0,
+					deferred: true
+				};
+			}
+			return {
+				success: true,
+				value: transform(result.value)
+			};
+		});
 	};
 	const dependencyMarkers = isWrappedDependencySource(parser) ? {
 		[wrappedDependencySourceMarker]: parser[wrappedDependencySourceMarker],
 		[transformsDependencyValueMarker]: true
 	} : {};
-	return {
+	const mappedParser = {
 		...parser,
 		$valueType: [],
 		complete,
@@ -441,6 +506,18 @@ function map(parser, transform) {
 			return parser.getDocFragments(state, void 0);
 		}
 	};
+	if ("placeholder" in parser) Object.defineProperty(mappedParser, "placeholder", {
+		get() {
+			try {
+				return transform(parser.placeholder);
+			} catch {
+				return void 0;
+			}
+		},
+		configurable: true,
+		enumerable: false
+	});
+	return mappedParser;
 }
 /**
 * Creates a parser that allows multiple occurrences of a given parser.
@@ -580,24 +657,41 @@ function multiple(parser, options = {}) {
 		complete(state) {
 			return dispatchByMode(parser.$mode, () => {
 				const result = [];
-				for (const s of state) {
-					const valueResult = completeSyncWithUnwrappedFallback(s);
-					if (valueResult.success) result.push(unwrapInjectedWrapper(valueResult.value));
-					else return {
+				const deferredIndices = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				for (let i = 0; i < state.length; i++) {
+					const valueResult = completeSyncWithUnwrappedFallback(state[i]);
+					if (valueResult.success) {
+						const unwrappedValue = unwrapInjectedWrapper(valueResult.value);
+						result.push(unwrappedValue);
+						if (valueResult.deferred) if (valueResult.deferredKeys) deferredIndices.set(i, valueResult.deferredKeys);
+						else if (unwrappedValue == null || typeof unwrappedValue !== "object") deferredIndices.set(i, null);
+						else hasDeferred = true;
+					} else return {
 						success: false,
 						error: valueResult.error
 					};
 				}
-				return validateMultipleResult(result);
+				return validateMultipleResult(result, deferredIndices, hasDeferred);
 			}, async () => {
 				const results = await Promise.all(state.map((s) => completeAsyncWithUnwrappedFallback(s)));
 				const values = [];
-				for (const valueResult of results) if (valueResult.success) values.push(unwrapInjectedWrapper(valueResult.value));
-				else return {
-					success: false,
-					error: valueResult.error
-				};
-				return validateMultipleResult(values);
+				const deferredIndices = /* @__PURE__ */ new Map();
+				let hasDeferred = false;
+				for (let i = 0; i < results.length; i++) {
+					const valueResult = results[i];
+					if (valueResult.success) {
+						const unwrappedValue = unwrapInjectedWrapper(valueResult.value);
+						values.push(unwrappedValue);
+						if (valueResult.deferred) if (valueResult.deferredKeys) deferredIndices.set(i, valueResult.deferredKeys);
+						else if (unwrappedValue == null || typeof unwrappedValue !== "object") deferredIndices.set(i, null);
+						else hasDeferred = true;
+					} else return {
+						success: false,
+						error: valueResult.error
+					};
+				}
+				return validateMultipleResult(values, deferredIndices, hasDeferred);
 			});
 		},
 		suggest(context, prefix) {
@@ -694,7 +788,7 @@ function multiple(parser, options = {}) {
 			return syncParser.getDocFragments(innerState, defaultValue != null && defaultValue.length > 0 ? defaultValue[0] : void 0);
 		}
 	};
-	function validateMultipleResult(result) {
+	function validateMultipleResult(result, deferredIndices, hasDeferred = false) {
 		if (result.length < min) {
 			const customMessage = options.errors?.tooFew;
 			return {
@@ -708,11 +802,26 @@ function multiple(parser, options = {}) {
 				error: customMessage ? typeof customMessage === "function" ? customMessage(max, result.length) : customMessage : message`Expected at most ${text(max.toLocaleString("en"))} values, but got ${text(result.length.toLocaleString("en"))}.`
 			};
 		}
+		const isDeferred = deferredIndices.size > 0 || hasDeferred;
 		return {
 			success: true,
-			value: result
+			value: result,
+			...isDeferred ? {
+				deferred: true,
+				...deferredIndices.size > 0 ? { deferredKeys: deferredIndices } : {}
+			} : {}
 		};
 	}
+	Object.defineProperty(resultParser, "placeholder", {
+		get() {
+			try {
+				if (min > 0 && "placeholder" in parser) return Array.from({ length: min }, () => parser.placeholder);
+			} catch {}
+			return [];
+		},
+		configurable: true,
+		enumerable: false
+	});
 	return resultParser;
 }
 /**
@@ -771,13 +880,14 @@ function nonEmpty(parser) {
 		const result = await parser.parse(context);
 		return processNonEmptyResult(result);
 	};
-	return {
+	const nonEmptyParser = {
 		$mode: parser.$mode,
 		$valueType: parser.$valueType,
 		$stateType: parser.$stateType,
 		priority: parser.priority,
 		usage: parser.usage,
 		initialState: parser.initialState,
+		...typeof parser.shouldDeferCompletion === "function" ? { shouldDeferCompletion: parser.shouldDeferCompletion.bind(parser) } : {},
 		parse(context) {
 			return dispatchByMode(parser.$mode, () => parseSync(context), () => parseAsync(context));
 		},
@@ -791,6 +901,14 @@ function nonEmpty(parser) {
 			return syncParser.getDocFragments(state, defaultValue);
 		}
 	};
+	if ("placeholder" in parser) Object.defineProperty(nonEmptyParser, "placeholder", {
+		get() {
+			return parser.placeholder;
+		},
+		configurable: true,
+		enumerable: false
+	});
+	return nonEmptyParser;
 }
 
 //#endregion

package/dist/parser.cjs

@@ -60,7 +60,9 @@ function parseSync(parser, args, options) {
 	const endResult = parser.complete(context.state);
 	return endResult.success ? {
 		success: true,
-		value: shouldUnwrapAnnotatedValue ? require_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value
+		value: shouldUnwrapAnnotatedValue ? require_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value,
+		...endResult.deferred ? { deferred: true } : {},
+		...endResult.deferredKeys ? { deferredKeys: endResult.deferredKeys } : {}
 	} : {
 		success: false,
 		error: endResult.error
@@ -110,7 +112,9 @@ async function parseAsync(parser, args, options) {
 	const endResult = await parser.complete(context.state);
 	return endResult.success ? {
 		success: true,
-		value: shouldUnwrapAnnotatedValue ? require_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value
+		value: shouldUnwrapAnnotatedValue ? require_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value,
+		...endResult.deferred ? { deferred: true } : {},
+		...endResult.deferredKeys ? { deferredKeys: endResult.deferredKeys } : {}
 	} : {
 		success: false,
 		error: endResult.error