@optique/core 1.3.0-dev.2488 → 1.3.0-dev.2497

package/dist/internal/parser.cjs

@@ -91,6 +91,160 @@ function createParserContext(frame, exec) {
 function injectAnnotationsIntoState(state, options) {
 	return require_internal_annotations.injectAnnotations(state, options?.annotations);
 }
+function getFailureProgress(args, buffer, consumedInStep) {
+	return {
+		remainingArgs: buffer.slice(consumedInStep),
+		consumedCount: args.length - buffer.length + consumedInStep
+	};
+}
+function createParseExec(parser) {
+	return {
+		usage: parser.usage,
+		phase: "parse",
+		path: [],
+		commandPath: [],
+		trace: require_input_trace.createInputTrace()
+	};
+}
+function getCommandPath(exec) {
+	return [...exec?.commandPath ?? []];
+}
+function createCompleteExec(exec, context, session) {
+	const runtime = require_dependency_runtime.createDependencyRuntimeContext();
+	return {
+		...exec,
+		phase: "complete",
+		dependencyRuntime: runtime,
+		dependencyRegistry: runtime.registry,
+		commandPath: context.exec?.commandPath ?? exec.commandPath,
+		trace: context.exec?.trace ?? context.trace ?? exec.trace,
+		effectfulCompletionSession: session ?? createEffectfulCompletionSession()
+	};
+}
+function attemptParseSync(parser, args, options = {}) {
+	const initialState = injectAnnotationsIntoState(parser.initialState, options.parseOptions);
+	const shouldUnwrapAnnotatedValue = require_internal_annotations.hasMeaningfulAnnotations(options.parseOptions?.annotations) || require_internal_annotations.isInjectedAnnotationWrapper(parser.initialState);
+	const exec = createParseExec(parser);
+	let context = createParserContext({
+		buffer: [...args],
+		state: initialState,
+		optionsTerminated: false
+	}, exec);
+	do {
+		const result = parser.parse(context);
+		if (!result.success) {
+			const progress = getFailureProgress(args, context.buffer, result.consumed);
+			return {
+				kind: "failure",
+				error: result.error,
+				remainingArgs: progress.remainingArgs,
+				consumedCount: progress.consumedCount,
+				optionsTerminated: context.optionsTerminated,
+				commandPath: getCommandPath(context.exec)
+			};
+		}
+		const previousBuffer = context.buffer;
+		context = result.next;
+		if (isBufferUnchanged(previousBuffer, context.buffer)) {
+			const progress = getFailureProgress(args, previousBuffer, result.consumed.length);
+			return {
+				kind: "failure",
+				error: require_message.message`Unexpected option or argument: ${context.buffer[0]}.`,
+				remainingArgs: progress.remainingArgs,
+				consumedCount: progress.consumedCount,
+				optionsTerminated: context.optionsTerminated,
+				commandPath: getCommandPath(context.exec)
+			};
+		}
+	} while (context.buffer.length > 0);
+	if (options.mode === "parse-only") return {
+		kind: "success",
+		result: {
+			success: true,
+			value: void 0
+		}
+	};
+	const endResult = parser.complete(context.state, createCompleteExec(exec, context, options.session));
+	if (!endResult.success) return {
+		kind: "failure",
+		error: endResult.error,
+		remainingArgs: [],
+		consumedCount: args.length,
+		optionsTerminated: context.optionsTerminated,
+		commandPath: getCommandPath(context.exec)
+	};
+	return {
+		kind: "success",
+		result: {
+			success: true,
+			value: shouldUnwrapAnnotatedValue ? require_internal_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value,
+			...endResult.deferred ? { deferred: true } : {},
+			...endResult.deferredKeys ? { deferredKeys: endResult.deferredKeys } : {}
+		}
+	};
+}
+async function attemptParseAsync(parser, args, options = {}) {
+	const initialState = injectAnnotationsIntoState(parser.initialState, options.parseOptions);
+	const shouldUnwrapAnnotatedValue = require_internal_annotations.hasMeaningfulAnnotations(options.parseOptions?.annotations) || require_internal_annotations.isInjectedAnnotationWrapper(parser.initialState);
+	const exec = createParseExec(parser);
+	let context = createParserContext({
+		buffer: [...args],
+		state: initialState,
+		optionsTerminated: false
+	}, exec);
+	do {
+		const result = await parser.parse(context);
+		if (!result.success) {
+			const progress = getFailureProgress(args, context.buffer, result.consumed);
+			return {
+				kind: "failure",
+				error: result.error,
+				remainingArgs: progress.remainingArgs,
+				consumedCount: progress.consumedCount,
+				optionsTerminated: context.optionsTerminated,
+				commandPath: getCommandPath(context.exec)
+			};
+		}
+		const previousBuffer = context.buffer;
+		context = result.next;
+		if (isBufferUnchanged(previousBuffer, context.buffer)) {
+			const progress = getFailureProgress(args, previousBuffer, result.consumed.length);
+			return {
+				kind: "failure",
+				error: require_message.message`Unexpected option or argument: ${context.buffer[0]}.`,
+				remainingArgs: progress.remainingArgs,
+				consumedCount: progress.consumedCount,
+				optionsTerminated: context.optionsTerminated,
+				commandPath: getCommandPath(context.exec)
+			};
+		}
+	} while (context.buffer.length > 0);
+	if (options.mode === "parse-only") return {
+		kind: "success",
+		result: {
+			success: true,
+			value: void 0
+		}
+	};
+	const endResult = await parser.complete(context.state, createCompleteExec(exec, context, options.session));
+	if (!endResult.success) return {
+		kind: "failure",
+		error: endResult.error,
+		remainingArgs: [],
+		consumedCount: args.length,
+		optionsTerminated: context.optionsTerminated,
+		commandPath: getCommandPath(context.exec)
+	};
+	return {
+		kind: "success",
+		result: {
+			success: true,
+			value: shouldUnwrapAnnotatedValue ? require_internal_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value,
+			...endResult.deferred ? { deferred: true } : {},
+			...endResult.deferredKeys ? { deferredKeys: endResult.deferredKeys } : {}
+		}
+	};
+}
 /**
 * Parses an array of command-line arguments using the provided combined parser.
 * This function processes the input arguments, applying the parser to each
@@ -116,51 +270,10 @@ function injectAnnotationsIntoState(state, options) {
 * @since 0.10.0 Added optional `options` parameter for annotations support.
 */
 function parseSync(parser, args, options) {
-	const initialState = injectAnnotationsIntoState(parser.initialState, options);
-	const shouldUnwrapAnnotatedValue = require_internal_annotations.hasMeaningfulAnnotations(options?.annotations) || require_internal_annotations.isInjectedAnnotationWrapper(parser.initialState);
-	const exec = {
-		usage: parser.usage,
-		phase: "parse",
-		path: [],
-		trace: require_input_trace.createInputTrace()
-	};
-	let context = createParserContext({
-		buffer: args,
-		state: initialState,
-		optionsTerminated: false
-	}, exec);
-	do {
-		const result = parser.parse(context);
-		if (!result.success) return {
-			success: false,
-			error: result.error
-		};
-		const previousBuffer = context.buffer;
-		context = result.next;
-		if (isBufferUnchanged(previousBuffer, context.buffer)) return {
-			success: false,
-			error: require_message.message`Unexpected option or argument: ${context.buffer[0]}.`
-		};
-	} while (context.buffer.length > 0);
-	const runtime = require_dependency_runtime.createDependencyRuntimeContext();
-	const completeExec = {
-		...exec,
-		phase: "complete",
-		dependencyRuntime: runtime,
-		dependencyRegistry: runtime.registry,
-		commandPath: context.exec?.commandPath ?? exec.commandPath,
-		trace: context.exec?.trace ?? context.trace ?? exec.trace,
-		effectfulCompletionSession: createEffectfulCompletionSession()
-	};
-	const endResult = parser.complete(context.state, completeExec);
-	return endResult.success ? {
-		success: true,
-		value: shouldUnwrapAnnotatedValue ? require_internal_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value,
-		...endResult.deferred ? { deferred: true } : {},
-		...endResult.deferredKeys ? { deferredKeys: endResult.deferredKeys } : {}
-	} : {
+	const attempted = attemptParseSync(parser, args, { parseOptions: options });
+	return attempted.kind === "success" ? attempted.result : {
 		success: false,
-		error: endResult.error
+		error: attempted.error
 	};
 }
 /**
@@ -190,52 +303,47 @@ function isBufferUnchanged(previous, current) {
 * @since 0.10.0 Added optional `options` parameter for annotations support.
 */
 async function parseAsync(parser, args, options) {
-	const initialState = injectAnnotationsIntoState(parser.initialState, options);
-	const shouldUnwrapAnnotatedValue = require_internal_annotations.hasMeaningfulAnnotations(options?.annotations) || require_internal_annotations.isInjectedAnnotationWrapper(parser.initialState);
-	const exec = {
-		usage: parser.usage,
-		phase: "parse",
-		path: [],
-		trace: require_input_trace.createInputTrace()
+	const attempted = await attemptParseAsync(parser, args, { parseOptions: options });
+	return attempted.kind === "success" ? attempted.result : {
+		success: false,
+		error: attempted.error
 	};
-	let context = createParserContext({
-		buffer: args,
-		state: initialState,
-		optionsTerminated: false
-	}, exec);
-	do {
-		const result = await parser.parse(context);
-		if (!result.success) return {
+}
+/**
+* Parses a complete argument list while preserving failure progress.
+*
+* The return mode follows the parser: synchronous parsers return immediately,
+* while asynchronous parsers return a promise.  Use this lower-level API when
+* a caller needs the unconsumed argument suffix or matched command path.
+*
+* @template M The execution mode of the parser.
+* @template T The type of the value produced by the parser.
+* @param parser The parser to run.
+* @param args The complete argument list to parse.
+* @param options Optional parsing annotations.
+* @returns A detailed success or failure result in the parser's mode.
+* @throws {TypeError} When a synchronous dependency source extractor returns a
+*         thenable during completion-time dependency seeding.
+* @since 1.3.0
+*/
+function parseDetailed(parser, args, options) {
+	return require_mode_dispatch.dispatchParserByMode(parser, (parser$1) => {
+		const attempted = attemptParseSync(parser$1, args, { parseOptions: options });
+		return attempted.kind === "success" ? attempted.result : {
 			success: false,
-			error: result.error
+			error: attempted.error,
+			remainingArgs: attempted.remainingArgs,
+			commandPath: attempted.commandPath
 		};
-		const previousBuffer = context.buffer;
-		context = result.next;
-		if (isBufferUnchanged(previousBuffer, context.buffer)) return {
+	}, async (parser$1) => {
+		const attempted = await attemptParseAsync(parser$1, args, { parseOptions: options });
+		return attempted.kind === "success" ? attempted.result : {
 			success: false,
-			error: require_message.message`Unexpected option or argument: ${context.buffer[0]}.`
+			error: attempted.error,
+			remainingArgs: attempted.remainingArgs,
+			commandPath: attempted.commandPath
 		};
-	} while (context.buffer.length > 0);
-	const runtime = require_dependency_runtime.createDependencyRuntimeContext();
-	const completeExec = {
-		...exec,
-		phase: "complete",
-		dependencyRuntime: runtime,
-		dependencyRegistry: runtime.registry,
-		commandPath: context.exec?.commandPath ?? exec.commandPath,
-		trace: context.exec?.trace ?? context.trace ?? exec.trace,
-		effectfulCompletionSession: createEffectfulCompletionSession()
-	};
-	const endResult = await parser.complete(context.state, completeExec);
-	return endResult.success ? {
-		success: true,
-		value: shouldUnwrapAnnotatedValue ? require_internal_annotations.unwrapInjectedAnnotationWrapper(endResult.value) : endResult.value,
-		...endResult.deferred ? { deferred: true } : {},
-		...endResult.deferredKeys ? { deferredKeys: endResult.deferredKeys } : {}
-	} : {
-		success: false,
-		error: endResult.error
-	};
+	});
 }
 /**
 * Parses an array of command-line arguments using the provided combined parser.
@@ -904,6 +1012,8 @@ function findNextMatchedCommandArgIndex(args, matchedCommandArgIndices, start) {
 
 //#endregion
 exports.annotationWrapperRequiresSourceBindingKey = annotationWrapperRequiresSourceBindingKey;
+exports.attemptParseAsync = attemptParseAsync;
+exports.attemptParseSync = attemptParseSync;
 exports.composeWrappedSourceMetadata = composeWrappedSourceMetadata;
 exports.createEffectfulCompletionSession = createEffectfulCompletionSession;
 exports.createParserContext = createParserContext;
@@ -919,6 +1029,7 @@ exports.getParserSuggestRuntimeNodes = getParserSuggestRuntimeNodes;
 exports.inheritParentAnnotationsKey = inheritParentAnnotationsKey;
 exports.parse = parse;
 exports.parseAsync = parseAsync;
+exports.parseDetailed = parseDetailed;
 exports.parseLanesKey = parseLanesKey;
 exports.parseSync = parseSync;
 exports.suggest = suggest;

package/dist/internal/parser.d.cts

@@ -885,6 +885,59 @@ type Result<T> = {
    */
   readonly error: Message;
 };
+/**
+ * The result of a whole parser operation with failure progress preserved.
+ *
+ * Successful results have the same shape as {@link Result}.  Failures also
+ * identify the unconsumed argument suffix and the canonical command path
+ * matched before the failure.
+ *
+ * @template T The type of the value produced by the parser.
+ * @since 1.3.0
+ */
+type DetailedParseResult<T> = Extract<Result<T>, {
+  readonly success: true;
+}> | {
+  /** Indicates that the parsing operation failed. */
+  readonly success: false;
+  /** The error message describing why parsing failed. */
+  readonly error: Message;
+  /** The arguments that remained at the point of failure. */
+  readonly remainingArgs: readonly string[];
+  /** The canonical names of commands matched before the failure. */
+  readonly commandPath: readonly string[];
+};
+/** @internal */
+type ParseAttempt<T> = {
+  readonly kind: "success";
+  readonly result: Extract<Result<T>, {
+    readonly success: true;
+  }>;
+} | {
+  readonly kind: "failure";
+  readonly error: Message;
+  readonly remainingArgs: readonly string[];
+  readonly consumedCount: number;
+  readonly optionsTerminated: boolean;
+  readonly commandPath: readonly string[];
+};
+interface ParseAttemptOptions {
+  readonly mode?: "complete" | "parse-only";
+  readonly session?: EffectfulCompletionSession;
+  readonly parseOptions?: ParseOptions;
+}
+/** @internal */
+declare function attemptParseSync<T>(parser: Parser<"sync", T, unknown>, args: readonly string[], options?: ParseAttemptOptions): ParseAttempt<T>;
+/** @internal */
+declare function attemptParseSync(parser: Parser<"sync", unknown, unknown>, args: readonly string[], options: ParseAttemptOptions & {
+  readonly mode: "parse-only";
+}): ParseAttempt<undefined>;
+/** @internal */
+declare function attemptParseAsync<T>(parser: Parser<Mode, T, unknown>, args: readonly string[], options?: ParseAttemptOptions): Promise<ParseAttempt<T>>;
+/** @internal */
+declare function attemptParseAsync(parser: Parser<Mode, unknown, unknown>, args: readonly string[], options: ParseAttemptOptions & {
+  readonly mode: "parse-only";
+}): Promise<ParseAttempt<undefined>>;
 /**
  * Parses an array of command-line arguments using the provided combined parser.
  * This function processes the input arguments, applying the parser to each
@@ -930,6 +983,24 @@ declare function parseSync<T>(parser: Parser<"sync", T, unknown>, args: readonly
  * @since 0.10.0 Added optional `options` parameter for annotations support.
  */
 declare function parseAsync<T>(parser: Parser<Mode, T, unknown>, args: readonly string[], options?: ParseOptions): Promise<Result<T>>;
+/**
+ * Parses a complete argument list while preserving failure progress.
+ *
+ * The return mode follows the parser: synchronous parsers return immediately,
+ * while asynchronous parsers return a promise.  Use this lower-level API when
+ * a caller needs the unconsumed argument suffix or matched command path.
+ *
+ * @template M The execution mode of the parser.
+ * @template T The type of the value produced by the parser.
+ * @param parser The parser to run.
+ * @param args The complete argument list to parse.
+ * @param options Optional parsing annotations.
+ * @returns A detailed success or failure result in the parser's mode.
+ * @throws {TypeError} When a synchronous dependency source extractor returns a
+ *         thenable during completion-time dependency seeding.
+ * @since 1.3.0
+ */
+declare function parseDetailed<M extends Mode, T>(parser: Parser<M, T, unknown>, args: readonly string[], options?: ParseOptions): ModeValue<M, DetailedParseResult<T>>;
 /**
  * Parses an array of command-line arguments using the provided combined parser.
  * This function processes the input arguments, applying the parser to each
@@ -1188,4 +1259,4 @@ declare function getDocPage(parser: Parser<"sync", unknown, unknown>, argsOrOpti
 declare function getDocPage(parser: Parser<"async", unknown, unknown>, argsOrOptions?: readonly string[] | ParseOptions, options?: ParseOptions): Promise<DocPage | undefined>;
 declare function getDocPage<M extends Mode>(parser: Parser<M, unknown, unknown>, argsOrOptions?: readonly string[] | ParseOptions, options?: ParseOptions): ModeValue<M, DocPage | undefined>;
 //#endregion
-export { CombineModes, DocState, EffectfulCompletionSession, ExecutionContext, ExecutionPhase, InferMode, InferValue, Mode, ModeIterable, ModeValue, ParseFrame, ParseLane, ParseLaneConsumptionGroup, type ParseOptions, Parser, ParserContext, ParserResult, Result, Suggestion, annotationWrapperRequiresSourceBindingKey, composeWrappedSourceMetadata, createEffectfulCompletionSession, createParserContext, defineInheritedAnnotationParser, defineParseLanes, defineSourceBindingOnlyAnnotationCompletionParser, getDelegatingSuggestRuntimeNodes, getDocPage, getDocPageAsync, getDocPageSync, getOwnParseLanes, getParserSuggestRuntimeNodes, inheritParentAnnotationsKey, parse, parseAsync, parseLanesKey, parseSync, suggest, suggestAsync, suggestSync, unmatchedNonCliDependencySourceStateMarker };
+export { CombineModes, DetailedParseResult, DocState, EffectfulCompletionSession, ExecutionContext, ExecutionPhase, InferMode, InferValue, Mode, ModeIterable, ModeValue, ParseAttempt, ParseFrame, ParseLane, ParseLaneConsumptionGroup, type ParseOptions, Parser, ParserContext, ParserResult, Result, Suggestion, annotationWrapperRequiresSourceBindingKey, attemptParseAsync, attemptParseSync, composeWrappedSourceMetadata, createEffectfulCompletionSession, createParserContext, defineInheritedAnnotationParser, defineParseLanes, defineSourceBindingOnlyAnnotationCompletionParser, getDelegatingSuggestRuntimeNodes, getDocPage, getDocPageAsync, getDocPageSync, getOwnParseLanes, getParserSuggestRuntimeNodes, inheritParentAnnotationsKey, parse, parseAsync, parseDetailed, parseLanesKey, parseSync, suggest, suggestAsync, suggestSync, unmatchedNonCliDependencySourceStateMarker };

package/dist/internal/parser.d.ts

@@ -885,6 +885,59 @@ type Result<T> = {
    */
   readonly error: Message;
 };
+/**
+ * The result of a whole parser operation with failure progress preserved.
+ *
+ * Successful results have the same shape as {@link Result}.  Failures also
+ * identify the unconsumed argument suffix and the canonical command path
+ * matched before the failure.
+ *
+ * @template T The type of the value produced by the parser.
+ * @since 1.3.0
+ */
+type DetailedParseResult<T> = Extract<Result<T>, {
+  readonly success: true;
+}> | {
+  /** Indicates that the parsing operation failed. */
+  readonly success: false;
+  /** The error message describing why parsing failed. */
+  readonly error: Message;
+  /** The arguments that remained at the point of failure. */
+  readonly remainingArgs: readonly string[];
+  /** The canonical names of commands matched before the failure. */
+  readonly commandPath: readonly string[];
+};
+/** @internal */
+type ParseAttempt<T> = {
+  readonly kind: "success";
+  readonly result: Extract<Result<T>, {
+    readonly success: true;
+  }>;
+} | {
+  readonly kind: "failure";
+  readonly error: Message;
+  readonly remainingArgs: readonly string[];
+  readonly consumedCount: number;
+  readonly optionsTerminated: boolean;
+  readonly commandPath: readonly string[];
+};
+interface ParseAttemptOptions {
+  readonly mode?: "complete" | "parse-only";
+  readonly session?: EffectfulCompletionSession;
+  readonly parseOptions?: ParseOptions;
+}
+/** @internal */
+declare function attemptParseSync<T>(parser: Parser<"sync", T, unknown>, args: readonly string[], options?: ParseAttemptOptions): ParseAttempt<T>;
+/** @internal */
+declare function attemptParseSync(parser: Parser<"sync", unknown, unknown>, args: readonly string[], options: ParseAttemptOptions & {
+  readonly mode: "parse-only";
+}): ParseAttempt<undefined>;
+/** @internal */
+declare function attemptParseAsync<T>(parser: Parser<Mode, T, unknown>, args: readonly string[], options?: ParseAttemptOptions): Promise<ParseAttempt<T>>;
+/** @internal */
+declare function attemptParseAsync(parser: Parser<Mode, unknown, unknown>, args: readonly string[], options: ParseAttemptOptions & {
+  readonly mode: "parse-only";
+}): Promise<ParseAttempt<undefined>>;
 /**
  * Parses an array of command-line arguments using the provided combined parser.
  * This function processes the input arguments, applying the parser to each
@@ -930,6 +983,24 @@ declare function parseSync<T>(parser: Parser<"sync", T, unknown>, args: readonly
  * @since 0.10.0 Added optional `options` parameter for annotations support.
  */
 declare function parseAsync<T>(parser: Parser<Mode, T, unknown>, args: readonly string[], options?: ParseOptions): Promise<Result<T>>;
+/**
+ * Parses a complete argument list while preserving failure progress.
+ *
+ * The return mode follows the parser: synchronous parsers return immediately,
+ * while asynchronous parsers return a promise.  Use this lower-level API when
+ * a caller needs the unconsumed argument suffix or matched command path.
+ *
+ * @template M The execution mode of the parser.
+ * @template T The type of the value produced by the parser.
+ * @param parser The parser to run.
+ * @param args The complete argument list to parse.
+ * @param options Optional parsing annotations.
+ * @returns A detailed success or failure result in the parser's mode.
+ * @throws {TypeError} When a synchronous dependency source extractor returns a
+ *         thenable during completion-time dependency seeding.
+ * @since 1.3.0
+ */
+declare function parseDetailed<M extends Mode, T>(parser: Parser<M, T, unknown>, args: readonly string[], options?: ParseOptions): ModeValue<M, DetailedParseResult<T>>;
 /**
  * Parses an array of command-line arguments using the provided combined parser.
  * This function processes the input arguments, applying the parser to each
@@ -1188,4 +1259,4 @@ declare function getDocPage(parser: Parser<"sync", unknown, unknown>, argsOrOpti
 declare function getDocPage(parser: Parser<"async", unknown, unknown>, argsOrOptions?: readonly string[] | ParseOptions, options?: ParseOptions): Promise<DocPage | undefined>;
 declare function getDocPage<M extends Mode>(parser: Parser<M, unknown, unknown>, argsOrOptions?: readonly string[] | ParseOptions, options?: ParseOptions): ModeValue<M, DocPage | undefined>;
 //#endregion
-export { CombineModes, DocState, EffectfulCompletionSession, ExecutionContext, ExecutionPhase, InferMode, InferValue, Mode, ModeIterable, ModeValue, ParseFrame, ParseLane, ParseLaneConsumptionGroup, type ParseOptions, Parser, ParserContext, ParserResult, Result, Suggestion, annotationWrapperRequiresSourceBindingKey, composeWrappedSourceMetadata, createEffectfulCompletionSession, createParserContext, defineInheritedAnnotationParser, defineParseLanes, defineSourceBindingOnlyAnnotationCompletionParser, getDelegatingSuggestRuntimeNodes, getDocPage, getDocPageAsync, getDocPageSync, getOwnParseLanes, getParserSuggestRuntimeNodes, inheritParentAnnotationsKey, parse, parseAsync, parseLanesKey, parseSync, suggest, suggestAsync, suggestSync, unmatchedNonCliDependencySourceStateMarker };
+export { CombineModes, DetailedParseResult, DocState, EffectfulCompletionSession, ExecutionContext, ExecutionPhase, InferMode, InferValue, Mode, ModeIterable, ModeValue, ParseAttempt, ParseFrame, ParseLane, ParseLaneConsumptionGroup, type ParseOptions, Parser, ParserContext, ParserResult, Result, Suggestion, annotationWrapperRequiresSourceBindingKey, attemptParseAsync, attemptParseSync, composeWrappedSourceMetadata, createEffectfulCompletionSession, createParserContext, defineInheritedAnnotationParser, defineParseLanes, defineSourceBindingOnlyAnnotationCompletionParser, getDelegatingSuggestRuntimeNodes, getDocPage, getDocPageAsync, getDocPageSync, getOwnParseLanes, getParserSuggestRuntimeNodes, inheritParentAnnotationsKey, parse, parseAsync, parseDetailed, parseLanesKey, parseSync, suggest, suggestAsync, suggestSync, unmatchedNonCliDependencySourceStateMarker };