@optique/core 1.0.0-dev.429 → 1.0.0-dev.431

package/dist/context.d.cts

@@ -46,6 +46,10 @@ type ParserValuePlaceholder = {
  * - *Dynamic*: Data depends on parsing results (e.g., config files whose path
  *   is determined by a CLI option)
  *
+ * Contexts may optionally implement `Disposable` or `AsyncDisposable` for
+ * cleanup.  When present, `runWith()` and `runWithSync()` call the dispose
+ * method in a `finally` block after parsing completes.
+ *
  * @template TRequiredOptions Additional options that `runWith()` must provide
  *   when this context is used. Use `void` (the default) for contexts that
  *   don't require extra options. Use {@link ParserValuePlaceholder} in option
@@ -88,7 +92,7 @@ interface SourceContext<TRequiredOptions = void> {
    * Type-level marker for the required options. Not used at runtime.
    * @internal
    */
-  readonly _requiredOptions?: TRequiredOptions;
+  readonly $requiredOptions?: TRequiredOptions;
   /**
    * Get annotations to inject into parsing.
    *
@@ -103,10 +107,24 @@ interface SourceContext<TRequiredOptions = void> {
    * @param parsed Optional parsed result from a previous parse pass.
    *               Static contexts can ignore this parameter.
    *               Dynamic contexts use this to extract necessary data.
+   * @param options Optional context-required options provided by the caller
+   *               of `runWith()`. These are the options declared via the
+   *               `TRequiredOptions` type parameter.
    * @returns Annotations to merge into the parsing session. Can be a Promise
    *          for async operations (e.g., loading config files).
    */
-  getAnnotations(parsed?: unknown): Promise<Annotations> | Annotations;
+  getAnnotations(parsed?: unknown, options?: unknown): Promise<Annotations> | Annotations;
+  /**
+   * Optional synchronous cleanup method.  Called by `runWith()` and
+   * `runWithSync()` in a `finally` block after parsing completes.
+   */
+  [Symbol.dispose]?(): void;
+  /**
+   * Optional asynchronous cleanup method.  Called by `runWith()` in a
+   * `finally` block after parsing completes.  Takes precedence over
+   * `[Symbol.dispose]` in async runners.
+   */
+  [Symbol.asyncDispose]?(): void | PromiseLike<void>;
 }
 /**
  * Checks whether a context is static (returns annotations without needing

package/dist/context.d.ts

@@ -46,6 +46,10 @@ type ParserValuePlaceholder = {
  * - *Dynamic*: Data depends on parsing results (e.g., config files whose path
  *   is determined by a CLI option)
  *
+ * Contexts may optionally implement `Disposable` or `AsyncDisposable` for
+ * cleanup.  When present, `runWith()` and `runWithSync()` call the dispose
+ * method in a `finally` block after parsing completes.
+ *
  * @template TRequiredOptions Additional options that `runWith()` must provide
  *   when this context is used. Use `void` (the default) for contexts that
  *   don't require extra options. Use {@link ParserValuePlaceholder} in option
@@ -88,7 +92,7 @@ interface SourceContext<TRequiredOptions = void> {
    * Type-level marker for the required options. Not used at runtime.
    * @internal
    */
-  readonly _requiredOptions?: TRequiredOptions;
+  readonly $requiredOptions?: TRequiredOptions;
   /**
    * Get annotations to inject into parsing.
    *
@@ -103,10 +107,24 @@ interface SourceContext<TRequiredOptions = void> {
    * @param parsed Optional parsed result from a previous parse pass.
    *               Static contexts can ignore this parameter.
    *               Dynamic contexts use this to extract necessary data.
+   * @param options Optional context-required options provided by the caller
+   *               of `runWith()`. These are the options declared via the
+   *               `TRequiredOptions` type parameter.
    * @returns Annotations to merge into the parsing session. Can be a Promise
    *          for async operations (e.g., loading config files).
    */
-  getAnnotations(parsed?: unknown): Promise<Annotations> | Annotations;
+  getAnnotations(parsed?: unknown, options?: unknown): Promise<Annotations> | Annotations;
+  /**
+   * Optional synchronous cleanup method.  Called by `runWith()` and
+   * `runWithSync()` in a `finally` block after parsing completes.
+   */
+  [Symbol.dispose]?(): void;
+  /**
+   * Optional asynchronous cleanup method.  Called by `runWith()` in a
+   * `finally` block after parsing completes.  Takes precedence over
+   * `[Symbol.dispose]` in async runners.
+   */
+  [Symbol.asyncDispose]?(): void | PromiseLike<void>;
 }
 /**
  * Checks whether a context is static (returns annotations without needing

package/dist/facade.cjs

@@ -820,13 +820,14 @@ function mergeAnnotations(annotationsList) {
 * two-phase parsing is needed.
 *
 * @param contexts Source contexts to collect annotations from.
+* @param options Optional context-required options to pass to each context.
 * @returns Promise with merged annotations and dynamic-context hint.
 */
-async function collectPhase1Annotations(contexts) {
+async function collectPhase1Annotations(contexts, options) {
 	const annotationsList = [];
 	let hasDynamic = false;
 	for (const context of contexts) {
-		const result = context.getAnnotations();
+		const result = context.getAnnotations(void 0, options);
 		if (result instanceof Promise) {
 			hasDynamic = true;
 			annotationsList.push(await result);
@@ -845,12 +846,13 @@ async function collectPhase1Annotations(contexts) {
 *
 * @param contexts Source contexts to collect annotations from.
 * @param parsed Optional parsed result from a previous parse pass.
+* @param options Optional context-required options to pass to each context.
 * @returns Promise that resolves to merged annotations.
 */
-async function collectAnnotations(contexts, parsed) {
+async function collectAnnotations(contexts, parsed, options) {
 	const annotationsList = [];
 	for (const context of contexts) {
-		const result = context.getAnnotations(parsed);
+		const result = context.getAnnotations(parsed, options);
 		annotationsList.push(result instanceof Promise ? await result : result);
 	}
 	return mergeAnnotations(annotationsList);
@@ -860,14 +862,15 @@ async function collectAnnotations(contexts, parsed) {
 * whether two-phase parsing is needed.
 *
 * @param contexts Source contexts to collect annotations from.
+* @param options Optional context-required options to pass to each context.
 * @returns Merged annotations with dynamic-context hint.
 * @throws Error if any context returns a Promise.
 */
-function collectPhase1AnnotationsSync(contexts) {
+function collectPhase1AnnotationsSync(contexts, options) {
 	const annotationsList = [];
 	let hasDynamic = false;
 	for (const context of contexts) {
-		const result = context.getAnnotations();
+		const result = context.getAnnotations(void 0, options);
 		if (result instanceof Promise) throw new Error(`Context ${String(context.id)} returned a Promise in sync mode. Use runWith() or runWithAsync() for async contexts.`);
 		if (Object.getOwnPropertySymbols(result).length === 0) hasDynamic = true;
 		annotationsList.push(result);
@@ -882,19 +885,38 @@ function collectPhase1AnnotationsSync(contexts) {
 *
 * @param contexts Source contexts to collect annotations from.
 * @param parsed Optional parsed result from a previous parse pass.
+* @param options Optional context-required options to pass to each context.
 * @returns Merged annotations.
 * @throws Error if any context returns a Promise.
 */
-function collectAnnotationsSync(contexts, parsed) {
+function collectAnnotationsSync(contexts, parsed, options) {
 	const annotationsList = [];
 	for (const context of contexts) {
-		const result = context.getAnnotations(parsed);
+		const result = context.getAnnotations(parsed, options);
 		if (result instanceof Promise) throw new Error(`Context ${String(context.id)} returned a Promise in sync mode. Use runWith() or runWithAsync() for async contexts.`);
 		annotationsList.push(result);
 	}
 	return mergeAnnotations(annotationsList);
 }
 /**
+* Disposes all contexts that implement `AsyncDisposable` or `Disposable`.
+* Prefers `[Symbol.asyncDispose]` over `[Symbol.dispose]`.
+*
+* @param contexts Source contexts to dispose.
+*/
+async function disposeContexts(contexts) {
+	for (const context of contexts) if (Symbol.asyncDispose in context && typeof context[Symbol.asyncDispose] === "function") await context[Symbol.asyncDispose]();
+	else if (Symbol.dispose in context && typeof context[Symbol.dispose] === "function") context[Symbol.dispose]();
+}
+/**
+* Disposes all contexts that implement `Disposable` synchronously.
+*
+* @param contexts Source contexts to dispose.
+*/
+function disposeContextsSync(contexts) {
+	for (const context of contexts) if (Symbol.dispose in context && typeof context[Symbol.dispose] === "function") context[Symbol.dispose]();
+}
+/**
 * Runs a parser with multiple source contexts.
 *
 * This function automatically handles static and dynamic contexts with proper
@@ -952,36 +974,40 @@ async function runWith(parser, programName, contexts, options) {
 		if (parser.$mode === "async") return runParser(parser, programName, args, options);
 		return Promise.resolve(runParser(parser, programName, args, options));
 	}
-	const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = await collectPhase1Annotations(contexts);
-	if (!needsTwoPhase) {
-		const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
-		if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
-		return Promise.resolve(runParser(augmentedParser, programName, args, options));
-	}
-	const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
-	let firstPassResult;
-	let firstPassFailed = false;
 	try {
-		if (parser.$mode === "async") firstPassResult = await require_parser.parseAsync(augmentedParser1, args);
-		else firstPassResult = require_parser.parseSync(augmentedParser1, args);
-		if (typeof firstPassResult === "object" && firstPassResult !== null && "success" in firstPassResult) {
-			const result = firstPassResult;
-			if (result.success) firstPassResult = result.value;
-			else firstPassFailed = true;
+		const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = await collectPhase1Annotations(contexts, options);
+		if (!needsTwoPhase) {
+			const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
+			if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
+			return Promise.resolve(runParser(augmentedParser, programName, args, options));
 		}
-	} catch {
-		firstPassFailed = true;
-	}
-	if (firstPassFailed) {
-		const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
-		if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
-		return Promise.resolve(runParser(augmentedParser, programName, args, options));
+		const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
+		let firstPassResult;
+		let firstPassFailed = false;
+		try {
+			if (parser.$mode === "async") firstPassResult = await require_parser.parseAsync(augmentedParser1, args);
+			else firstPassResult = require_parser.parseSync(augmentedParser1, args);
+			if (typeof firstPassResult === "object" && firstPassResult !== null && "success" in firstPassResult) {
+				const result = firstPassResult;
+				if (result.success) firstPassResult = result.value;
+				else firstPassFailed = true;
+			}
+		} catch {
+			firstPassFailed = true;
+		}
+		if (firstPassFailed) {
+			const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
+			if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
+			return Promise.resolve(runParser(augmentedParser, programName, args, options));
+		}
+		const phase2Annotations = await collectAnnotations(contexts, firstPassResult, options);
+		const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
+		const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
+		if (parser.$mode === "async") return runParser(augmentedParser2, programName, args, options);
+		return Promise.resolve(runParser(augmentedParser2, programName, args, options));
+	} finally {
+		await disposeContexts(contexts);
 	}
-	const phase2Annotations = await collectAnnotations(contexts, firstPassResult);
-	const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
-	const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
-	if (parser.$mode === "async") return runParser(augmentedParser2, programName, args, options);
-	return Promise.resolve(runParser(augmentedParser2, programName, args, options));
 }
 /**
 * Runs a synchronous parser with multiple source contexts.
@@ -1004,24 +1030,28 @@ function runWithSync(parser, programName, contexts, options) {
 	const args = options?.args ?? [];
 	if (needsEarlyExit(args, options)) return runParser(parser, programName, args, options);
 	if (contexts.length === 0) return runParser(parser, programName, args, options);
-	const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = collectPhase1AnnotationsSync(contexts);
-	if (!needsTwoPhase) {
-		const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
-		return runParser(augmentedParser, programName, args, options);
-	}
-	const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
-	let firstPassResult;
 	try {
-		const result = require_parser.parseSync(augmentedParser1, args);
-		if (result.success) firstPassResult = result.value;
-		else return runParser(augmentedParser1, programName, args, options);
-	} catch {
-		return runParser(augmentedParser1, programName, args, options);
+		const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = collectPhase1AnnotationsSync(contexts, options);
+		if (!needsTwoPhase) {
+			const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
+			return runParser(augmentedParser, programName, args, options);
+		}
+		const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
+		let firstPassResult;
+		try {
+			const result = require_parser.parseSync(augmentedParser1, args);
+			if (result.success) firstPassResult = result.value;
+			else return runParser(augmentedParser1, programName, args, options);
+		} catch {
+			return runParser(augmentedParser1, programName, args, options);
+		}
+		const phase2Annotations = collectAnnotationsSync(contexts, firstPassResult, options);
+		const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
+		const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
+		return runParser(augmentedParser2, programName, args, options);
+	} finally {
+		disposeContextsSync(contexts);
 	}
-	const phase2Annotations = collectAnnotationsSync(contexts, firstPassResult);
-	const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
-	const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
-	return runParser(augmentedParser2, programName, args, options);
 }
 /**
 * Runs any parser asynchronously with multiple source contexts.

package/dist/facade.js

@@ -820,13 +820,14 @@ function mergeAnnotations(annotationsList) {
 * two-phase parsing is needed.
 *
 * @param contexts Source contexts to collect annotations from.
+* @param options Optional context-required options to pass to each context.
 * @returns Promise with merged annotations and dynamic-context hint.
 */
-async function collectPhase1Annotations(contexts) {
+async function collectPhase1Annotations(contexts, options) {
 	const annotationsList = [];
 	let hasDynamic = false;
 	for (const context of contexts) {
-		const result = context.getAnnotations();
+		const result = context.getAnnotations(void 0, options);
 		if (result instanceof Promise) {
 			hasDynamic = true;
 			annotationsList.push(await result);
@@ -845,12 +846,13 @@ async function collectPhase1Annotations(contexts) {
 *
 * @param contexts Source contexts to collect annotations from.
 * @param parsed Optional parsed result from a previous parse pass.
+* @param options Optional context-required options to pass to each context.
 * @returns Promise that resolves to merged annotations.
 */
-async function collectAnnotations(contexts, parsed) {
+async function collectAnnotations(contexts, parsed, options) {
 	const annotationsList = [];
 	for (const context of contexts) {
-		const result = context.getAnnotations(parsed);
+		const result = context.getAnnotations(parsed, options);
 		annotationsList.push(result instanceof Promise ? await result : result);
 	}
 	return mergeAnnotations(annotationsList);
@@ -860,14 +862,15 @@ async function collectAnnotations(contexts, parsed) {
 * whether two-phase parsing is needed.
 *
 * @param contexts Source contexts to collect annotations from.
+* @param options Optional context-required options to pass to each context.
 * @returns Merged annotations with dynamic-context hint.
 * @throws Error if any context returns a Promise.
 */
-function collectPhase1AnnotationsSync(contexts) {
+function collectPhase1AnnotationsSync(contexts, options) {
 	const annotationsList = [];
 	let hasDynamic = false;
 	for (const context of contexts) {
-		const result = context.getAnnotations();
+		const result = context.getAnnotations(void 0, options);
 		if (result instanceof Promise) throw new Error(`Context ${String(context.id)} returned a Promise in sync mode. Use runWith() or runWithAsync() for async contexts.`);
 		if (Object.getOwnPropertySymbols(result).length === 0) hasDynamic = true;
 		annotationsList.push(result);
@@ -882,19 +885,38 @@ function collectPhase1AnnotationsSync(contexts) {
 *
 * @param contexts Source contexts to collect annotations from.
 * @param parsed Optional parsed result from a previous parse pass.
+* @param options Optional context-required options to pass to each context.
 * @returns Merged annotations.
 * @throws Error if any context returns a Promise.
 */
-function collectAnnotationsSync(contexts, parsed) {
+function collectAnnotationsSync(contexts, parsed, options) {
 	const annotationsList = [];
 	for (const context of contexts) {
-		const result = context.getAnnotations(parsed);
+		const result = context.getAnnotations(parsed, options);
 		if (result instanceof Promise) throw new Error(`Context ${String(context.id)} returned a Promise in sync mode. Use runWith() or runWithAsync() for async contexts.`);
 		annotationsList.push(result);
 	}
 	return mergeAnnotations(annotationsList);
 }
 /**
+* Disposes all contexts that implement `AsyncDisposable` or `Disposable`.
+* Prefers `[Symbol.asyncDispose]` over `[Symbol.dispose]`.
+*
+* @param contexts Source contexts to dispose.
+*/
+async function disposeContexts(contexts) {
+	for (const context of contexts) if (Symbol.asyncDispose in context && typeof context[Symbol.asyncDispose] === "function") await context[Symbol.asyncDispose]();
+	else if (Symbol.dispose in context && typeof context[Symbol.dispose] === "function") context[Symbol.dispose]();
+}
+/**
+* Disposes all contexts that implement `Disposable` synchronously.
+*
+* @param contexts Source contexts to dispose.
+*/
+function disposeContextsSync(contexts) {
+	for (const context of contexts) if (Symbol.dispose in context && typeof context[Symbol.dispose] === "function") context[Symbol.dispose]();
+}
+/**
 * Runs a parser with multiple source contexts.
 *
 * This function automatically handles static and dynamic contexts with proper
@@ -952,36 +974,40 @@ async function runWith(parser, programName, contexts, options) {
 		if (parser.$mode === "async") return runParser(parser, programName, args, options);
 		return Promise.resolve(runParser(parser, programName, args, options));
 	}
-	const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = await collectPhase1Annotations(contexts);
-	if (!needsTwoPhase) {
-		const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
-		if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
-		return Promise.resolve(runParser(augmentedParser, programName, args, options));
-	}
-	const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
-	let firstPassResult;
-	let firstPassFailed = false;
 	try {
-		if (parser.$mode === "async") firstPassResult = await parseAsync(augmentedParser1, args);
-		else firstPassResult = parseSync(augmentedParser1, args);
-		if (typeof firstPassResult === "object" && firstPassResult !== null && "success" in firstPassResult) {
-			const result = firstPassResult;
-			if (result.success) firstPassResult = result.value;
-			else firstPassFailed = true;
+		const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = await collectPhase1Annotations(contexts, options);
+		if (!needsTwoPhase) {
+			const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
+			if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
+			return Promise.resolve(runParser(augmentedParser, programName, args, options));
 		}
-	} catch {
-		firstPassFailed = true;
-	}
-	if (firstPassFailed) {
-		const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
-		if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
-		return Promise.resolve(runParser(augmentedParser, programName, args, options));
+		const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
+		let firstPassResult;
+		let firstPassFailed = false;
+		try {
+			if (parser.$mode === "async") firstPassResult = await parseAsync(augmentedParser1, args);
+			else firstPassResult = parseSync(augmentedParser1, args);
+			if (typeof firstPassResult === "object" && firstPassResult !== null && "success" in firstPassResult) {
+				const result = firstPassResult;
+				if (result.success) firstPassResult = result.value;
+				else firstPassFailed = true;
+			}
+		} catch {
+			firstPassFailed = true;
+		}
+		if (firstPassFailed) {
+			const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
+			if (parser.$mode === "async") return runParser(augmentedParser, programName, args, options);
+			return Promise.resolve(runParser(augmentedParser, programName, args, options));
+		}
+		const phase2Annotations = await collectAnnotations(contexts, firstPassResult, options);
+		const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
+		const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
+		if (parser.$mode === "async") return runParser(augmentedParser2, programName, args, options);
+		return Promise.resolve(runParser(augmentedParser2, programName, args, options));
+	} finally {
+		await disposeContexts(contexts);
 	}
-	const phase2Annotations = await collectAnnotations(contexts, firstPassResult);
-	const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
-	const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
-	if (parser.$mode === "async") return runParser(augmentedParser2, programName, args, options);
-	return Promise.resolve(runParser(augmentedParser2, programName, args, options));
 }
 /**
 * Runs a synchronous parser with multiple source contexts.
@@ -1004,24 +1030,28 @@ function runWithSync(parser, programName, contexts, options) {
 	const args = options?.args ?? [];
 	if (needsEarlyExit(args, options)) return runParser(parser, programName, args, options);
 	if (contexts.length === 0) return runParser(parser, programName, args, options);
-	const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = collectPhase1AnnotationsSync(contexts);
-	if (!needsTwoPhase) {
-		const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
-		return runParser(augmentedParser, programName, args, options);
-	}
-	const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
-	let firstPassResult;
 	try {
-		const result = parseSync(augmentedParser1, args);
-		if (result.success) firstPassResult = result.value;
-		else return runParser(augmentedParser1, programName, args, options);
-	} catch {
-		return runParser(augmentedParser1, programName, args, options);
+		const { annotations: phase1Annotations, hasDynamic: needsTwoPhase } = collectPhase1AnnotationsSync(contexts, options);
+		if (!needsTwoPhase) {
+			const augmentedParser = injectAnnotationsIntoParser(parser, phase1Annotations);
+			return runParser(augmentedParser, programName, args, options);
+		}
+		const augmentedParser1 = injectAnnotationsIntoParser(parser, phase1Annotations);
+		let firstPassResult;
+		try {
+			const result = parseSync(augmentedParser1, args);
+			if (result.success) firstPassResult = result.value;
+			else return runParser(augmentedParser1, programName, args, options);
+		} catch {
+			return runParser(augmentedParser1, programName, args, options);
+		}
+		const phase2Annotations = collectAnnotationsSync(contexts, firstPassResult, options);
+		const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
+		const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
+		return runParser(augmentedParser2, programName, args, options);
+	} finally {
+		disposeContextsSync(contexts);
 	}
-	const phase2Annotations = collectAnnotationsSync(contexts, firstPassResult);
-	const finalAnnotations = mergeAnnotations([phase1Annotations, phase2Annotations]);
-	const augmentedParser2 = injectAnnotationsIntoParser(parser, finalAnnotations);
-	return runParser(augmentedParser2, programName, args, options);
 }
 /**
 * Runs any parser asynchronously with multiple source contexts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optique/core",
-  "version": "1.0.0-dev.429+66edc8ed",
+  "version": "1.0.0-dev.431+01c1abaf",
   "description": "Type-safe combinatorial command-line interface parser",
   "keywords": [
     "CLI",