markform 0.1.16 → 0.1.18

package/dist/{src-Dv3IZSQU.mjs → src-DDxi-2ne.mjs}

@@ -1,6 +1,6 @@
 
-import { L as PatchSchema, V as RunModeSchema } from "./coreTypes-DiCddBKu.mjs";
-import { C as DEFAULT_MAX_TURNS, D as DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN, E as DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN, G as MarkformConfigError, J as MarkformParseError, O as DEFAULT_ROLES, S as DEFAULT_MAX_STEPS_PER_TURN, T as DEFAULT_PRIORITY, V as getWebSearchConfig, b as DEFAULT_MAX_ISSUES_PER_TURN, d as serializeForm, g as preprocessCommentSyntax, h as detectSyntaxStyle, i as inspect, k as DEFAULT_ROLE_INSTRUCTIONS, r as getFieldsForRoles, t as applyPatches, v as AGENT_ROLE, x as DEFAULT_MAX_PATCHES_PER_TURN } from "./apply-CXsI5N9x.mjs";
+import { L as PatchSchema, V as RunModeSchema } from "./coreTypes-SDB3KRRJ.mjs";
+import { A as DEFAULT_ROLE_INSTRUCTIONS, C as DEFAULT_MAX_STEPS_PER_TURN, D as DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN, E as DEFAULT_PRIORITY, H as getWebSearchConfig, K as MarkformConfigError, O as DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN, S as DEFAULT_MAX_PATCHES_PER_TURN, Y as MarkformParseError, b as DEFAULT_MAX_ISSUES_PER_TURN, d as serializeForm, g as preprocessCommentSyntax, h as detectSyntaxStyle, i as inspect, k as DEFAULT_ROLES, r as getFieldsForRoles, t as applyPatches, v as AGENT_ROLE, w as DEFAULT_MAX_TURNS, x as DEFAULT_MAX_PARALLEL_AGENTS } from "./apply-BYgtU64w.mjs";
 import { z } from "zod";
 import Markdoc from "@markdoc/markdoc";
 import YAML from "yaml";
@@ -588,14 +588,16 @@ function parseBaseFieldAttrs(node, kind) {
 	};
 }
 /**
-* Get common field attributes (priority, role, validate, report).
+* Get common field attributes (priority, role, validate, report, parallel, order).
 */
 function getCommonFieldAttrs(node) {
 	return {
 		priority: getPriorityAttr(node),
 		role: getStringAttr(node, "role") ?? AGENT_ROLE,
 		validate: getValidateAttr(node),
-		report: getBooleanAttr(node, "report")
+		report: getBooleanAttr(node, "report"),
+		parallel: getStringAttr(node, "parallel"),
+		order: getNumberAttr(node, "order")
 	};
 }
 /**
@@ -1125,11 +1127,23 @@ const LEGACY_TAG_TO_KIND = {
 	"table-field": "table"
 };
 /**
+* Recursively check if any children of a node are field tags.
+* Throws MarkformParseError if a nested field is found.
+*/
+function validateNoNestedFields(node, outerFieldId) {
+	if (!node.children || !Array.isArray(node.children)) return;
+	for (const child of node.children) {
+		if (isTagNode(child, "field")) throw new MarkformParseError(`Field tags cannot be nested. Found '${getStringAttr(child, "id") ?? "unknown"}' inside '${outerFieldId}'`);
+		validateNoNestedFields(child, outerFieldId);
+	}
+}
+/**
 * Parse a unified field tag: {% field kind="..." ... %}
 */
 function parseUnifiedField(node) {
 	const kind = getStringAttr(node, "kind");
 	if (!kind) throw new MarkformParseError("field tag missing required 'kind' attribute");
+	validateNoNestedFields(node, getStringAttr(node, "id") ?? "unknown");
 	if (!FIELD_KINDS.includes(kind)) throw new MarkformParseError(`field tag has invalid kind '${kind}'. Valid kinds: ${FIELD_KINDS.join(", ")}`);
 	switch (kind) {
 		case "string": return parseStringField(node);
@@ -1159,6 +1173,274 @@ function parseField(node) {
 	return null;
 }
 
+//#endregion
+//#region src/markdown/markdownHeaders.ts
+const ATX_HEADING_PATTERN = /^(#{1,6})\s+(.*)$/;
+/**
+* Find all headings in a markdown document.
+* Returns headings in document order.
+*
+* Only ATX-style headings (# Title) are recognized.
+* Headings inside fenced code blocks are ignored.
+*/
+function findAllHeadings(markdown) {
+	const lines = markdown.split("\n");
+	const headings = [];
+	let inCodeBlock = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		const lineNumber = i + 1;
+		if (line.startsWith("```") || line.startsWith("~~~")) {
+			inCodeBlock = !inCodeBlock;
+			continue;
+		}
+		if (inCodeBlock) continue;
+		const match = ATX_HEADING_PATTERN.exec(line);
+		if (match) {
+			const hashes = match[1] ?? "";
+			const title = (match[2] ?? "").trim();
+			headings.push({
+				level: hashes.length,
+				title,
+				line: lineNumber,
+				position: {
+					start: {
+						line: lineNumber,
+						col: 1
+					},
+					end: {
+						line: lineNumber,
+						col: line.length + 1
+					}
+				}
+			});
+		}
+	}
+	return headings;
+}
+/**
+* Find all headings that enclose a given line position.
+* Returns headings from innermost (most specific) to outermost (least specific).
+*
+* A heading "encloses" a line if:
+* 1. The heading appears before the line
+* 2. No heading of equal or higher level appears between them
+*
+* @param markdown - The markdown source text
+* @param line - The line number (1-indexed)
+* @returns Array of enclosing headings, innermost first
+*/
+function findEnclosingHeadings(markdown, line) {
+	if (line <= 0) return [];
+	const precedingHeadings = findAllHeadings(markdown).filter((h) => h.line < line);
+	if (precedingHeadings.length === 0) return [];
+	const result = [];
+	let minLevelSeen = Infinity;
+	for (let i = precedingHeadings.length - 1; i >= 0; i--) {
+		const heading = precedingHeadings[i];
+		if (!heading) continue;
+		if (heading.level < minLevelSeen) {
+			result.push(heading);
+			minLevelSeen = heading.level;
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/engine/injectIds.ts
+const CHECKBOX_PATTERN = /^(\s*)-\s+(\[[^\]]\])\s+(.*)$/;
+const MARKDOC_ID_PATTERN = /\{%\s*#(\w+)\s*%\}/;
+const HTML_COMMENT_ID_PATTERN = /<!--\s*#(\w+)\s*-->/;
+/**
+* Find all checkboxes in a markdown document.
+* Returns checkboxes in document order with enclosing heading info.
+*/
+function findAllCheckboxes(markdown) {
+	const lines = markdown.split("\n");
+	const checkboxes = [];
+	let inCodeBlock = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		const lineNumber = i + 1;
+		if (line.trimStart().startsWith("```") || line.trimStart().startsWith("~~~")) {
+			inCodeBlock = !inCodeBlock;
+			continue;
+		}
+		if (inCodeBlock) continue;
+		const match = CHECKBOX_PATTERN.exec(line);
+		if (!match) continue;
+		const marker$2 = match[2] ?? "";
+		const rest = match[3] ?? "";
+		const state = CHECKBOX_MARKERS[marker$2];
+		if (state === void 0) continue;
+		let label = rest;
+		let id;
+		const markdocMatch = MARKDOC_ID_PATTERN.exec(rest);
+		if (markdocMatch) {
+			id = markdocMatch[1];
+			label = rest.replace(MARKDOC_ID_PATTERN, "").trim();
+		} else {
+			const htmlMatch = HTML_COMMENT_ID_PATTERN.exec(rest);
+			if (htmlMatch) {
+				id = htmlMatch[1];
+				label = rest.replace(HTML_COMMENT_ID_PATTERN, "").trim();
+			}
+		}
+		const enclosingHeadings = findEnclosingHeadings(markdown, lineNumber);
+		checkboxes.push({
+			id,
+			label,
+			state,
+			line: lineNumber,
+			position: {
+				start: {
+					line: lineNumber,
+					col: 1
+				},
+				end: {
+					line: lineNumber,
+					col: line.length + 1
+				}
+			},
+			enclosingHeadings
+		});
+	}
+	return checkboxes;
+}
+/**
+* Inject IDs into checkboxes in a markdown document.
+*
+* Uses a generator function to create unique IDs for each checkbox.
+* Throws if duplicate IDs are generated or if generated IDs conflict
+* with existing ones.
+*/
+function injectCheckboxIds(markdown, options) {
+	const { generator, onlyMissing = true } = options;
+	const checkboxes = findAllCheckboxes(markdown);
+	const existingIds = /* @__PURE__ */ new Set();
+	for (const checkbox of checkboxes) if (checkbox.id && onlyMissing) existingIds.add(checkbox.id);
+	const needsId = checkboxes.filter((cb) => onlyMissing ? !cb.id : true);
+	const generatedIds = /* @__PURE__ */ new Map();
+	const allGeneratedIds = /* @__PURE__ */ new Set();
+	for (let i = 0; i < needsId.length; i++) {
+		const checkbox = needsId[i];
+		const newId = generator(checkbox, i);
+		if (allGeneratedIds.has(newId)) throw new MarkformParseError(`Duplicate generated ID '${newId}' for checkbox '${checkbox.label}'`, { line: checkbox.line });
+		if (onlyMissing && existingIds.has(newId)) throw new MarkformParseError(`Generated ID '${newId}' conflicts with existing ID`, { line: checkbox.line });
+		allGeneratedIds.add(newId);
+		generatedIds.set(checkbox.label, newId);
+	}
+	if (needsId.length === 0) return {
+		markdown,
+		injectedCount: 0,
+		injectedIds: /* @__PURE__ */ new Map()
+	};
+	const lines = markdown.split("\n");
+	const sortedByLine = [...needsId].sort((a, b) => b.line - a.line);
+	for (const checkbox of sortedByLine) {
+		const lineIndex = checkbox.line - 1;
+		const line = lines[lineIndex];
+		const newId = generatedIds.get(checkbox.label);
+		let updatedLine = line;
+		if (!onlyMissing || checkbox.id) {
+			updatedLine = updatedLine.replace(MARKDOC_ID_PATTERN, "").trim();
+			updatedLine = updatedLine.replace(HTML_COMMENT_ID_PATTERN, "").trim();
+		}
+		lines[lineIndex] = `${updatedLine} {% #${newId} %}`;
+	}
+	return {
+		markdown: lines.join("\n"),
+		injectedCount: needsId.length,
+		injectedIds: generatedIds
+	};
+}
+/**
+* Find all headings with their existing IDs.
+* Strips ID annotations from title for clean generator input.
+*/
+function findAllHeadingsWithIds(markdown) {
+	const headings = findAllHeadings(markdown);
+	const lines = markdown.split("\n");
+	return headings.map((heading) => {
+		const line = lines[heading.line - 1] ?? "";
+		let id;
+		let cleanTitle = heading.title;
+		const markdocMatch = MARKDOC_ID_PATTERN.exec(line);
+		if (markdocMatch) {
+			id = markdocMatch[1];
+			cleanTitle = heading.title.replace(MARKDOC_ID_PATTERN, "").trim();
+		} else {
+			const htmlMatch = HTML_COMMENT_ID_PATTERN.exec(line);
+			if (htmlMatch) {
+				id = htmlMatch[1];
+				cleanTitle = heading.title.replace(HTML_COMMENT_ID_PATTERN, "").trim();
+			}
+		}
+		return {
+			...heading,
+			title: cleanTitle,
+			id
+		};
+	});
+}
+/**
+* Inject IDs into headings in a markdown document.
+*
+* Uses a generator function to create unique IDs for each heading.
+* Throws if duplicate IDs are generated or if generated IDs conflict
+* with existing ones.
+*/
+function injectHeaderIds(markdown, options) {
+	const { generator, onlyMissing = true, levels = [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6
+	] } = options;
+	const allHeadings = findAllHeadingsWithIds(markdown);
+	const levelSet = new Set(levels);
+	const headings = allHeadings.filter((h) => levelSet.has(h.level));
+	const existingIds = /* @__PURE__ */ new Set();
+	for (const heading of headings) if (heading.id && onlyMissing) existingIds.add(heading.id);
+	const needsId = headings.filter((h) => onlyMissing ? !h.id : true);
+	const generatedIds = /* @__PURE__ */ new Map();
+	const allGeneratedIds = /* @__PURE__ */ new Set();
+	for (let i = 0; i < needsId.length; i++) {
+		const heading = needsId[i];
+		const newId = generator(heading, i);
+		if (allGeneratedIds.has(newId)) throw new MarkformParseError(`Duplicate generated ID '${newId}' for heading '${heading.title}'`, { line: heading.line });
+		if (onlyMissing && existingIds.has(newId)) throw new MarkformParseError(`Generated ID '${newId}' conflicts with existing ID`, { line: heading.line });
+		allGeneratedIds.add(newId);
+		generatedIds.set(heading.title, newId);
+	}
+	if (needsId.length === 0) return {
+		markdown,
+		injectedCount: 0,
+		injectedIds: /* @__PURE__ */ new Map()
+	};
+	const lines = markdown.split("\n");
+	const sortedByLine = [...needsId].sort((a, b) => b.line - a.line);
+	for (const heading of sortedByLine) {
+		const lineIndex = heading.line - 1;
+		const line = lines[lineIndex];
+		const newId = generatedIds.get(heading.title);
+		let updatedLine = line;
+		if (!onlyMissing || heading.id) {
+			updatedLine = updatedLine.replace(MARKDOC_ID_PATTERN, "").trim();
+			updatedLine = updatedLine.replace(HTML_COMMENT_ID_PATTERN, "").trim();
+		}
+		lines[lineIndex] = `${updatedLine} {% #${newId} %}`;
+	}
+	return {
+		markdown: lines.join("\n"),
+		injectedCount: needsId.length,
+		injectedIds: generatedIds
+	};
+}
+
 //#endregion
 //#region src/engine/parse.ts
 /**
@@ -1180,7 +1462,8 @@ const VALID_FORM_TAGS = new Set([
 ]);
 /**
 * Parse harness configuration from frontmatter.
-* Converts snake_case keys to camelCase.
+* YAML keys must be snake_case; they are mapped to camelCase internally.
+* Unrecognized keys produce a parse error.
 */
 function parseHarnessConfig(raw) {
 	if (!raw || typeof raw !== "object") return;
@@ -1188,15 +1471,15 @@ function parseHarnessConfig(raw) {
 	const result = {};
 	const keyMap = {
 		max_turns: "maxTurns",
-		maxTurns: "maxTurns",
 		max_patches_per_turn: "maxPatchesPerTurn",
-		maxPatchesPerTurn: "maxPatchesPerTurn",
 		max_issues_per_turn: "maxIssuesPerTurn",
-		maxIssuesPerTurn: "maxIssuesPerTurn"
+		max_parallel_agents: "maxParallelAgents"
 	};
 	for (const [key, value] of Object.entries(config)) {
 		const camelKey = keyMap[key];
-		if (camelKey && typeof value === "number") result[camelKey] = value;
+		if (!camelKey) throw new MarkformParseError(`Unknown harness config key '${key}'. Valid keys: ${Object.keys(keyMap).join(", ")}`);
+		if (typeof value !== "number") throw new MarkformParseError(`Harness config key '${key}' must be a number, got ${typeof value}`);
+		result[camelKey] = value;
 	}
 	return Object.keys(result).length > 0 ? result : void 0;
 }
@@ -1237,6 +1520,100 @@ function extractFrontmatter(ast) {
 	}
 }
 /**
+* Extract the raw source content minus frontmatter.
+* This is the content that will be used for splice-based serialization.
+*/
+function extractRawSource(preprocessed) {
+	const frontmatterMatch = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/.exec(preprocessed);
+	if (frontmatterMatch) return preprocessed.slice(frontmatterMatch[0].length);
+	return preprocessed;
+}
+/**
+* Build a line-to-offset mapping for converting Markdoc line numbers to byte offsets.
+* Returns an array where lineOffsets[lineNumber] = byte offset of line start.
+* Line numbers are 0-indexed (Markdoc uses 0-indexed lines).
+*/
+function buildLineOffsets(source) {
+	const offsets = [0];
+	for (let i = 0; i < source.length; i++) if (source[i] === "\n") offsets.push(i + 1);
+	return offsets;
+}
+/**
+* Extract tag region from a Markdoc AST node.
+* Uses the node's location property (line numbers) and converts to byte offsets.
+*/
+function extractTagRegion(node, tagType, tagId, lineOffsets, frontmatterLineCount, sourceLength, hasValue) {
+	const location = node.location;
+	if (!location?.start || !location?.end) return null;
+	const startLine = location.start.line - frontmatterLineCount;
+	const endLine = location.end.line - frontmatterLineCount;
+	if (startLine < 0 || endLine < 0) return null;
+	const startOffset = lineOffsets[startLine] ?? 0;
+	let endOffset;
+	if (endLine + 1 < lineOffsets.length) endOffset = lineOffsets[endLine + 1] ?? sourceLength;
+	else endOffset = sourceLength;
+	if (startOffset >= endOffset || startOffset < 0 || endOffset > sourceLength) return null;
+	return {
+		tagId,
+		tagType,
+		startOffset,
+		endOffset,
+		...hasValue !== void 0 && { includesValue: hasValue }
+	};
+}
+/**
+* Collect all tag regions from the AST for content preservation.
+* Traverses the AST and extracts positions of all Markform tags.
+*/
+function collectTagRegions(ast, rawSource, frontmatterLineCount, responsesByFieldId) {
+	const regions = [];
+	const lineOffsets = buildLineOffsets(rawSource);
+	const sourceLength = rawSource.length;
+	function traverse(node) {
+		if (!node || typeof node !== "object") return;
+		if (isTagNode(node, "form")) {
+			const id = getStringAttr(node, "id");
+			if (id) {
+				const region = extractTagRegion(node, "form", id, lineOffsets, frontmatterLineCount, sourceLength);
+				if (region) regions.push(region);
+			}
+		}
+		if (isTagNode(node, "group")) {
+			const id = getStringAttr(node, "id");
+			if (id) {
+				const region = extractTagRegion(node, "group", id, lineOffsets, frontmatterLineCount, sourceLength);
+				if (region) regions.push(region);
+			}
+		}
+		if (isTagNode(node, "field")) {
+			const id = getStringAttr(node, "id");
+			if (id) {
+				const region = extractTagRegion(node, "field", id, lineOffsets, frontmatterLineCount, sourceLength, responsesByFieldId[id]?.value !== void 0);
+				if (region) regions.push(region);
+			}
+		}
+		if (isTagNode(node, "note")) {
+			const id = getStringAttr(node, "id");
+			if (id) {
+				const region = extractTagRegion(node, "note", id, lineOffsets, frontmatterLineCount, sourceLength);
+				if (region) regions.push(region);
+			}
+		}
+		if (node.type === "tag" && node.tag && [
+			"instructions",
+			"description",
+			"documentation"
+		].includes(node.tag)) {
+			const region = extractTagRegion(node, "documentation", getStringAttr(node, "ref") ?? `doc_${regions.length}`, lineOffsets, frontmatterLineCount, sourceLength);
+			if (region) regions.push(region);
+		}
+		if (node.children && Array.isArray(node.children)) for (const child of node.children) traverse(child);
+	}
+	traverse(ast);
+	regions.sort((a, b) => a.startOffset - b.startOffset);
+	return regions;
+}
+/**
 * Parse a group tag.
 */
 function parseFieldGroup(node, responsesByFieldId, orderIndex, idIndex, parentId) {
@@ -1275,19 +1652,31 @@ function parseFieldGroup(node, responsesByFieldId, orderIndex, idIndex, parentId
 		if (child.children && Array.isArray(child.children)) for (const c of child.children) processChildren(c);
 	}
 	if (node.children && Array.isArray(node.children)) for (const child of node.children) processChildren(child);
+	const parallel = getStringAttr(node, "parallel");
+	const order = getNumberAttr(node, "order");
+	const groupEffectiveOrder = order ?? 0;
+	for (const child of children) {
+		if (child.parallel) throw new MarkformParseError(`Field '${child.id}' has parallel='${child.parallel}' but is inside group '${id}'. The parallel attribute is only allowed on top-level fields and groups.`);
+		if (child.order !== void 0) {
+			if (child.order !== groupEffectiveOrder) throw new MarkformParseError(`Field '${child.id}' has order=${child.order} but is inside group '${id}' with order=${groupEffectiveOrder}. A field inside a group must not specify a different order.`);
+		}
+	}
 	return {
 		id,
 		title,
 		validate: getValidateAttr(node),
 		children,
-		report: getBooleanAttr(node, "report")
+		report: getBooleanAttr(node, "report"),
+		parallel,
+		order
 	};
 }
 /**
 * Parse a form tag.
 * Handles both explicit groups and fields placed directly under the form.
+* Also handles implicit checkboxes when form has no explicit fields.
 */
-function parseFormTag(node, responsesByFieldId, orderIndex, idIndex) {
+function parseFormTag(node, responsesByFieldId, orderIndex, idIndex, markdown) {
 	const id = getStringAttr(node, "id");
 	const title = getStringAttr(node, "title");
 	if (!id) throw new MarkformParseError("form missing required 'id' attribute");
@@ -1328,18 +1717,89 @@ function parseFormTag(node, responsesByFieldId, orderIndex, idIndex) {
 	}
 	if (node.children && Array.isArray(node.children)) for (const child of node.children) processContent(child);
 	if (ungroupedFields.length > 0) {
-		const implicitGroupId = `_default`;
-		if (idIndex.has(implicitGroupId)) throw new MarkformParseError(`ID '${implicitGroupId}' is reserved for implicit field groups. Please use a different ID for your field or group.`);
-		idIndex.set(implicitGroupId, {
-			nodeType: "group",
+		const implicitGroupId = "default";
+		const existingDefault = groups.find((g) => g.id === implicitGroupId);
+		if (existingDefault) existingDefault.children = [...existingDefault.children ?? [], ...ungroupedFields];
+		else {
+			idIndex.set(implicitGroupId, {
+				nodeType: "group",
+				parentId: id
+			});
+			groups.push({
+				id: implicitGroupId,
+				children: ungroupedFields,
+				implicit: true
+			});
+		}
+	}
+	const hasExplicitFields = ungroupedFields.length > 0 || groups.some((g) => g.children && g.children.length > 0);
+	const hasExplicitCheckboxStyleFields = groups.some((g) => g.children?.some((f) => f.kind === "checkboxes" || f.kind === "single_select" || f.kind === "multi_select"));
+	const allCheckboxes = findAllCheckboxes(markdown);
+	if (allCheckboxes.length > 0) if (hasExplicitFields) {
+		if (!hasExplicitCheckboxStyleFields) throw new MarkformParseError("Checkboxes found outside of field tags. Either wrap all checkboxes in fields or remove all explicit fields for implicit checkboxes mode.");
+	} else {
+		const seenIds = /* @__PURE__ */ new Set();
+		const options = [];
+		const values = {};
+		for (const checkbox of allCheckboxes) {
+			if (!checkbox.id) throw new MarkformParseError(`Option in implicit field 'checkboxes' missing ID annotation. Use {% #option_id %}`, { line: checkbox.line });
+			if (seenIds.has(checkbox.id)) throw new MarkformParseError(`Duplicate option ID '${checkbox.id}' in field 'checkboxes'`, { line: checkbox.line });
+			seenIds.add(checkbox.id);
+			options.push({
+				id: checkbox.id,
+				label: checkbox.label
+			});
+			values[checkbox.id] = checkbox.state;
+		}
+		const implicitField = {
+			kind: "checkboxes",
+			id: "checkboxes",
+			label: "Checkboxes",
+			checkboxMode: "multi",
+			implicit: true,
+			options,
+			required: false,
+			priority: DEFAULT_PRIORITY,
+			role: AGENT_ROLE,
+			approvalMode: "none"
+		};
+		idIndex.set("checkboxes", {
+			nodeType: "field",
 			parentId: id
 		});
-		groups.push({
-			id: implicitGroupId,
-			children: ungroupedFields,
-			implicit: true
-		});
+		orderIndex.push("checkboxes");
+		for (const opt of options) {
+			const qualifiedRef = `checkboxes.${opt.id}`;
+			idIndex.set(qualifiedRef, {
+				nodeType: "option",
+				parentId: id,
+				fieldId: "checkboxes"
+			});
+		}
+		responsesByFieldId.checkboxes = {
+			state: "answered",
+			value: {
+				kind: "checkboxes",
+				values
+			}
+		};
+		let defaultGroup = groups.find((g) => g.id === "default");
+		if (!defaultGroup) {
+			defaultGroup = {
+				id: "default",
+				children: [],
+				implicit: true
+			};
+			idIndex.set("default", {
+				nodeType: "group",
+				parentId: id
+			});
+			groups.push(defaultGroup);
+		}
+		defaultGroup.children = defaultGroup.children || [];
+		defaultGroup.children.push(implicitField);
 	}
+	validateParallelBatches(groups);
 	return {
 		id,
 		title,
@@ -1347,6 +1807,39 @@ function parseFormTag(node, responsesByFieldId, orderIndex, idIndex) {
 	};
 }
 /**
+* Validate that parallel batches have consistent order and role values.
+*/
+function validateParallelBatches(groups) {
+	const batches = /* @__PURE__ */ new Map();
+	for (const group of groups) if (group.implicit) {
+		for (const field of group.children) if (field.parallel) {
+			const list = batches.get(field.parallel) ?? [];
+			list.push({
+				order: field.order ?? 0,
+				role: field.role,
+				itemId: field.id
+			});
+			batches.set(field.parallel, list);
+		}
+	} else if (group.parallel) {
+		const groupRole = group.children[0]?.role ?? AGENT_ROLE;
+		const list = batches.get(group.parallel) ?? [];
+		list.push({
+			order: group.order ?? 0,
+			role: groupRole,
+			itemId: group.id
+		});
+		batches.set(group.parallel, list);
+	}
+	for (const [batchId, items] of batches) {
+		if (items.length < 2) continue;
+		const firstOrder = items[0].order;
+		const firstRole = items[0].role;
+		if (items.filter((i) => i.order !== firstOrder).length > 0) throw new MarkformParseError(`Parallel batch '${batchId}' has items with different order values (${[...new Set(items.map((i) => i.order))].join(", ")}). All items in a parallel batch must have the same order.`);
+		if (items.filter((i) => i.role !== firstRole).length > 0) throw new MarkformParseError(`Parallel batch '${batchId}' has items with different roles (${[...new Set(items.map((i) => i.role))].join(", ")}). All items in a parallel batch must have the same role.`);
+	}
+}
+/**
 * Extract all notes from AST.
 * Looks for {% note %} tags with id, ref, role, and optional state.
 */
@@ -1441,6 +1934,8 @@ function extractDocBlocks(ast, idIndex) {
 function parseForm(markdown) {
 	const syntaxStyle = detectSyntaxStyle(markdown);
 	const preprocessed = preprocessCommentSyntax(markdown);
+	const rawSource = extractRawSource(preprocessed);
+	const frontmatterLineCount = (preprocessed.slice(0, preprocessed.length - rawSource.length).match(/\n/g) ?? []).length;
 	const ast = Markdoc.parse(preprocessed);
 	const { metadata, description } = extractFrontmatter(ast);
 	let formSchema = null;
@@ -1451,25 +1946,31 @@ function parseForm(markdown) {
 		if (!node || typeof node !== "object") return;
 		if (isTagNode(node, "form")) {
 			if (formSchema) throw new MarkformParseError("Multiple form tags found - only one allowed");
-			formSchema = parseFormTag(node, responsesByFieldId, orderIndex, idIndex);
+			formSchema = parseFormTag(node, responsesByFieldId, orderIndex, idIndex, preprocessed);
 			return;
 		}
 		if (node.children && Array.isArray(node.children)) for (const child of node.children) findFormTag(child);
 	}
 	findFormTag(ast);
 	if (!formSchema) throw new MarkformParseError("No form tag found in document");
+	const schema = {
+		...formSchema,
+		...description && { description }
+	};
+	const notes = extractNotes(ast, idIndex);
+	const docs = extractDocBlocks(ast, idIndex);
+	const tagRegions = collectTagRegions(ast, rawSource, frontmatterLineCount, responsesByFieldId);
 	return {
-		schema: {
-			...formSchema,
-			...description && { description }
-		},
+		schema,
 		responsesByFieldId,
-		notes: extractNotes(ast, idIndex),
-		docs: extractDocBlocks(ast, idIndex),
+		notes,
+		docs,
 		orderIndex,
 		idIndex,
 		...metadata && { metadata },
-		syntaxStyle
+		syntaxStyle,
+		rawSource,
+		tagRegions
 	};
 }
 
@@ -2590,7 +3091,8 @@ var FormHarness = class {
 	* Applies issue filtering and computes step budget.
 	*/
 	computeStepResult(result) {
-		const limitedIssues = this.filterIssuesByScope(result.issues).slice(0, this.config.maxIssuesPerTurn);
+		const orderFiltered = this.filterIssuesByOrder(result.issues);
+		const limitedIssues = this.filterIssuesByScope(orderFiltered).slice(0, this.config.maxIssuesPerTurn);
 		const stepBudget = Math.min(this.config.maxPatchesPerTurn, limitedIssues.length);
 		return {
 			structureSummary: result.structureSummary,
@@ -2681,6 +3183,36 @@ var FormHarness = class {
 		return result;
 	}
 	/**
+	* Filter issues by order level.
+	*
+	* Only includes issues for fields at the current (lowest incomplete) order level.
+	* Fields at higher order levels are deferred until all lower-order fields are complete.
+	* If no order attributes are used, all issues pass through (all at order 0).
+	*/
+	filterIssuesByOrder(issues) {
+		const fieldOrderMap = /* @__PURE__ */ new Map();
+		for (const group of this.form.schema.groups) {
+			const groupOrder = group.order ?? 0;
+			for (const field of group.children) fieldOrderMap.set(field.id, field.order ?? groupOrder);
+		}
+		const openOrderLevels = /* @__PURE__ */ new Set();
+		for (const issue of issues) {
+			const fieldId = this.getFieldIdFromRef(issue.ref, issue.scope);
+			if (fieldId) {
+				const order = fieldOrderMap.get(fieldId) ?? 0;
+				openOrderLevels.add(order);
+			} else if (issue.scope === "form") openOrderLevels.add(0);
+		}
+		if (openOrderLevels.size <= 1) return issues;
+		const currentOrder = Math.min(...openOrderLevels);
+		return issues.filter((issue) => {
+			if (issue.scope === "form") return true;
+			const fieldId = this.getFieldIdFromRef(issue.ref, issue.scope);
+			if (!fieldId) return true;
+			return (fieldOrderMap.get(fieldId) ?? 0) === currentOrder;
+		});
+	}
+	/**
 	* Extract field ID from an issue ref.
 	*/
 	getFieldIdFromRef(ref, scope) {
@@ -2885,6 +3417,62 @@ function createMockAgent(completedForm) {
 	return new MockAgent(completedForm);
 }
 
+//#endregion
+//#region src/engine/executionPlan.ts
+/**
+* Compute an execution plan from a parsed form.
+*
+* Walks top-level items (groups, or individual fields in implicit groups)
+* in document order and partitions them by their `parallel` attribute:
+* - Items without `parallel` go to the loose-serial pool.
+* - Items with the same `parallel` value form a parallel batch.
+*
+* Also computes distinct order levels across all items.
+*/
+function computeExecutionPlan(form) {
+	const looseSerial = [];
+	const batchMap = /* @__PURE__ */ new Map();
+	const orderSet = /* @__PURE__ */ new Set();
+	for (const group of form.schema.groups) if (group.implicit) for (const field of group.children) {
+		const order = field.order ?? 0;
+		orderSet.add(order);
+		const item = {
+			itemId: field.id,
+			itemType: "field",
+			order
+		};
+		if (field.parallel) {
+			const list = batchMap.get(field.parallel) ?? [];
+			list.push(item);
+			batchMap.set(field.parallel, list);
+		} else looseSerial.push(item);
+	}
+	else {
+		const order = group.order ?? 0;
+		orderSet.add(order);
+		const item = {
+			itemId: group.id,
+			itemType: "group",
+			order
+		};
+		if (group.parallel) {
+			const list = batchMap.get(group.parallel) ?? [];
+			list.push(item);
+			batchMap.set(group.parallel, list);
+		} else looseSerial.push(item);
+	}
+	const parallelBatches = [];
+	for (const [batchId, items] of batchMap) parallelBatches.push({
+		batchId,
+		items
+	});
+	return {
+		looseSerial,
+		parallelBatches,
+		orderLevels: [...orderSet].sort((a, b) => a - b)
+	};
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/@ai-sdk+provider@3.0.0/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker$1 = "vercel.ai.error";
@@ -8671,6 +9259,185 @@ function getProviderInfo(provider) {
 	};
 }
 
+//#endregion
+//#region src/harness/parallelHarness.ts
+/**
+* Parallel Harness - Orchestrates concurrent agent execution for parallel form filling.
+*
+* Uses the execution plan to identify parallel batches and order levels,
+* spawns concurrent agents for batch items, merges patches, and applies them.
+*/
+/**
+* Get field IDs that belong to an execution plan item.
+*/
+function getFieldIdsForItem(form, item) {
+	if (item.itemType === "field") return [item.itemId];
+	const group = form.schema.groups.find((g) => g.id === item.itemId);
+	if (!group) return [];
+	return group.children.map((f) => f.id);
+}
+/**
+* Filter issues to only those relevant to an execution plan item's fields.
+* Form-scoped issues are excluded (they don't belong to individual agents).
+*/
+function scopeIssuesForItem(form, item, allIssues) {
+	const targetFieldIds = new Set(getFieldIdsForItem(form, item));
+	return allIssues.filter((issue) => {
+		if (issue.scope === "form") return false;
+		if (issue.scope === "field") return targetFieldIds.has(issue.ref);
+		if (issue.scope === "option") {
+			const dotIndex = issue.ref.indexOf(".");
+			const fieldId = dotIndex > 0 ? issue.ref.slice(0, dotIndex) : issue.ref;
+			return targetFieldIds.has(fieldId);
+		}
+		if (issue.scope === "cell") {
+			const dotIndex = issue.ref.indexOf(".");
+			const fieldId = dotIndex > 0 ? issue.ref.slice(0, dotIndex) : issue.ref;
+			return targetFieldIds.has(fieldId);
+		}
+		return false;
+	});
+}
+/**
+* Parallel harness that orchestrates concurrent agent execution.
+*/
+var ParallelHarness = class {
+	form;
+	plan;
+	config;
+	constructor(form, config = {}) {
+		this.form = form;
+		this.plan = computeExecutionPlan(form);
+		this.config = config;
+	}
+	/**
+	* Get the execution plan.
+	*/
+	getExecutionPlan() {
+		return this.plan;
+	}
+	/**
+	* Run a single order level: execute loose serial items with the primary agent,
+	* and parallel batch items concurrently.
+	*/
+	async runOrderLevel(order, primaryAgent) {
+		const maxPatches = this.config.maxPatchesPerTurn ?? 20;
+		let totalPatchesApplied = 0;
+		const errors = [];
+		const allIssues = inspect(this.form).issues;
+		const looseItems = this.plan.looseSerial.filter((i) => i.order === order);
+		for (const item of looseItems) {
+			const scopedIssues = scopeIssuesForItem(this.form, item, allIssues);
+			if (scopedIssues.length === 0) continue;
+			try {
+				const response = await primaryAgent.fillFormTool(scopedIssues, this.form, maxPatches);
+				if (response.patches.length > 0) {
+					const result = applyPatches(this.form, response.patches);
+					totalPatchesApplied += result.appliedPatches.length;
+				}
+			} catch (err) {
+				errors.push(`Loose serial item ${item.itemId}: ${String(err)}`);
+			}
+		}
+		for (const batch of this.plan.parallelBatches) {
+			const batchItems = batch.items.filter((i) => i.order === order);
+			if (batchItems.length === 0) continue;
+			this.config.onBatchStart?.(batch.batchId);
+			const batchIssues = inspect(this.form).issues;
+			const maxConcurrent = this.config.maxParallelAgents ?? DEFAULT_MAX_PARALLEL_AGENTS;
+			const agentPromises = [];
+			const itemFieldIds = /* @__PURE__ */ new Map();
+			for (let i = 0; i < batchItems.length; i++) {
+				const item = batchItems[i];
+				const scopedIssues = scopeIssuesForItem(this.form, item, batchIssues);
+				const targetFieldIds = getFieldIdsForItem(this.form, item);
+				itemFieldIds.set(i, targetFieldIds);
+				if (scopedIssues.length === 0) {
+					agentPromises.push(Promise.resolve({ patches: [] }));
+					continue;
+				}
+				const request = {
+					form: this.form,
+					targetFieldIds,
+					targetGroupIds: item.itemType === "group" ? [item.itemId] : [],
+					issues: scopedIssues
+				};
+				const agent = this.config.agentFactory ? this.config.agentFactory(request) : primaryAgent;
+				agentPromises.push(agent.fillFormTool(scopedIssues, this.form, maxPatches));
+			}
+			const results = await runWithConcurrency(agentPromises, maxConcurrent);
+			const allPatches = [];
+			for (const result of results) if (result.status === "fulfilled") allPatches.push(...result.value.patches);
+			else errors.push(`Parallel agent error: ${result.reason}`);
+			if (allPatches.length > 0) {
+				const applyResult = applyPatches(this.form, allPatches);
+				totalPatchesApplied += applyResult.appliedPatches.length;
+			}
+			this.config.onBatchComplete?.(batch.batchId);
+		}
+		return {
+			patchesApplied: totalPatchesApplied,
+			errors
+		};
+	}
+	/**
+	* Run all order levels sequentially, filling the entire form.
+	*/
+	async runAll(primaryAgent) {
+		let totalPatchesApplied = 0;
+		const orderLevelsProcessed = [];
+		const allErrors = [];
+		for (const order of this.plan.orderLevels) {
+			this.config.onOrderLevelStart?.(order);
+			const result = await this.runOrderLevel(order, primaryAgent);
+			totalPatchesApplied += result.patchesApplied;
+			orderLevelsProcessed.push(order);
+			allErrors.push(...result.errors);
+			this.config.onOrderLevelComplete?.(order);
+		}
+		return {
+			isComplete: inspect(this.form).isComplete,
+			totalPatchesApplied,
+			orderLevelsProcessed,
+			errors: allErrors
+		};
+	}
+};
+/**
+* Run promises with a concurrency limit.
+* Returns results in the same order as input.
+*/
+async function runWithConcurrency(promises, maxConcurrent) {
+	if (maxConcurrent >= promises.length) return Promise.allSettled(promises);
+	const results = new Array(promises.length);
+	let nextIndex = 0;
+	async function runNext() {
+		while (nextIndex < promises.length) {
+			const idx = nextIndex++;
+			try {
+				results[idx] = {
+					status: "fulfilled",
+					value: await promises[idx]
+				};
+			} catch (reason) {
+				results[idx] = {
+					status: "rejected",
+					reason
+				};
+			}
+		}
+	}
+	const workers = Array.from({ length: Math.min(maxConcurrent, promises.length) }, () => runNext());
+	await Promise.all(workers);
+	return results;
+}
+/**
+* Create a parallel harness for the given form.
+*/
+function createParallelHarness(form, config) {
+	return new ParallelHarness(form, config);
+}
+
 //#endregion
 //#region src/harness/programmaticFill.ts
 function buildErrorResult(form, errors, warnings) {
@@ -8798,6 +9565,9 @@ async function fillForm(options) {
 		}
 		inputContextWarnings = coercionResult.warnings;
 	}
+	if (options.enableParallel) {
+		if (computeExecutionPlan(form).parallelBatches.length > 0) return fillFormParallel(form, model, provider, options, totalPatches, inputContextWarnings);
+	}
 	const maxTurnsTotal = options.maxTurnsTotal ?? DEFAULT_MAX_TURNS;
 	const startingTurnNumber = options.startingTurnNumber ?? 0;
 	const maxPatchesPerTurn = options.maxPatchesPerTurn ?? DEFAULT_MAX_PATCHES_PER_TURN;
@@ -8903,6 +9673,169 @@ async function fillForm(options) {
 		message: `Reached maximum total turns (${maxTurnsTotal})`
 	}, inputContextWarnings, stepResult.issues);
 }
+/**
+* Fill a form using parallel execution.
+*
+* For each order level, runs serial items with the primary agent (multi-turn),
+* then runs parallel batch items concurrently (multi-turn per agent).
+*/
+async function fillFormParallel(form, model, provider, options, initialPatches, inputContextWarnings) {
+	const plan = computeExecutionPlan(form);
+	const maxTurnsTotal = options.maxTurnsTotal ?? DEFAULT_MAX_TURNS;
+	const startingTurnNumber = options.startingTurnNumber ?? 0;
+	const maxPatchesPerTurn = options.maxPatchesPerTurn ?? DEFAULT_MAX_PATCHES_PER_TURN;
+	const maxIssuesPerTurn = options.maxIssuesPerTurn ?? DEFAULT_MAX_ISSUES_PER_TURN;
+	const maxParallelAgents = options.maxParallelAgents ?? DEFAULT_MAX_PARALLEL_AGENTS;
+	const targetRoles = options.targetRoles ?? [AGENT_ROLE];
+	let totalPatches = initialPatches;
+	let turnCount = startingTurnNumber;
+	const primaryAgent = options._testAgent ?? createLiveAgent({
+		model,
+		systemPromptAddition: options.systemPromptAddition,
+		targetRole: targetRoles[0] ?? AGENT_ROLE,
+		provider,
+		enableWebSearch: options.enableWebSearch,
+		additionalTools: options.additionalTools,
+		callbacks: options.callbacks,
+		maxStepsPerTurn: options.maxStepsPerTurn
+	});
+	for (const order of plan.orderLevels) {
+		if (options.signal?.aborted) return buildResult(form, turnCount, totalPatches, {
+			ok: false,
+			reason: "cancelled"
+		}, inputContextWarnings);
+		if (turnCount >= maxTurnsTotal) return buildResult(form, turnCount, totalPatches, {
+			ok: false,
+			reason: "max_turns",
+			message: `Reached maximum total turns (${maxTurnsTotal})`
+		}, inputContextWarnings);
+		try {
+			options.callbacks?.onOrderLevelStart?.({ order });
+		} catch {}
+		const serialItems = plan.looseSerial.filter((i) => i.order === order);
+		if (serialItems.length > 0) {
+			const result = await runMultiTurnForItems(form, primaryAgent, serialItems, targetRoles, maxPatchesPerTurn, maxIssuesPerTurn, maxTurnsTotal, turnCount, options);
+			totalPatches += result.patchesApplied;
+			turnCount += result.turnsUsed;
+			if (result.aborted) return buildResult(form, turnCount, totalPatches, result.status, inputContextWarnings);
+		}
+		for (const batch of plan.parallelBatches) {
+			const batchItems = batch.items.filter((i) => i.order === order);
+			if (batchItems.length === 0) continue;
+			try {
+				options.callbacks?.onBatchStart?.({
+					batchId: batch.batchId,
+					itemCount: batchItems.length
+				});
+			} catch {}
+			const results = await runWithConcurrency(batchItems.map((item) => {
+				return runMultiTurnForItems(form, options._testAgent ?? createLiveAgent({
+					model,
+					systemPromptAddition: options.systemPromptAddition,
+					targetRole: targetRoles[0] ?? AGENT_ROLE,
+					provider,
+					enableWebSearch: options.enableWebSearch,
+					additionalTools: options.additionalTools,
+					callbacks: options.callbacks,
+					maxStepsPerTurn: options.maxStepsPerTurn
+				}), [item], targetRoles, maxPatchesPerTurn, maxIssuesPerTurn, maxTurnsTotal, turnCount, options);
+			}).map((p) => p), maxParallelAgents);
+			let batchPatches = 0;
+			for (const result of results) if (result.status === "fulfilled") {
+				totalPatches += result.value.patchesApplied;
+				batchPatches += result.value.patchesApplied;
+				turnCount += result.value.turnsUsed;
+			}
+			try {
+				options.callbacks?.onBatchComplete?.({
+					batchId: batch.batchId,
+					patchesApplied: batchPatches
+				});
+			} catch {}
+		}
+		const levelInspect = inspect(form);
+		try {
+			options.callbacks?.onOrderLevelComplete?.({
+				order,
+				patchesApplied: totalPatches
+			});
+		} catch {}
+		if (levelInspect.isComplete) return buildResult(form, turnCount, totalPatches, { ok: true }, inputContextWarnings);
+	}
+	const finalInspect = inspect(form);
+	if (finalInspect.isComplete) return buildResult(form, turnCount, totalPatches, { ok: true }, inputContextWarnings);
+	return buildResult(form, turnCount, totalPatches, {
+		ok: false,
+		reason: "max_turns",
+		message: `Reached maximum total turns (${maxTurnsTotal})`
+	}, inputContextWarnings, finalInspect.issues);
+}
+/**
+* Run a multi-turn loop for a set of execution plan items.
+* Scoped issues are filtered to only the target items' fields.
+* Retries with rejection feedback, same as the serial fillForm path.
+*/
+async function runMultiTurnForItems(form, agent, items, targetRoles, maxPatchesPerTurn, _maxIssuesPerTurn, maxTurnsTotal, startTurn, options) {
+	let turnsUsed = 0;
+	let patchesApplied = 0;
+	let previousRejections;
+	const maxTurnsForItems = Math.min(maxTurnsTotal - startTurn, options.maxTurnsThisCall ?? Infinity);
+	for (let turn = 0; turn < maxTurnsForItems; turn++) {
+		if (options.signal?.aborted) return {
+			patchesApplied,
+			turnsUsed,
+			aborted: true,
+			status: {
+				ok: false,
+				reason: "cancelled"
+			}
+		};
+		const allIssues = inspect(form, { targetRoles }).issues;
+		let scopedIssues = [];
+		for (const item of items) scopedIssues.push(...scopeIssuesForItem(form, item, allIssues));
+		const seen = /* @__PURE__ */ new Set();
+		scopedIssues = scopedIssues.filter((issue) => {
+			const key = `${issue.scope}:${issue.ref}:${issue.message}`;
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		if (scopedIssues.length === 0) break;
+		try {
+			options.callbacks?.onTurnStart?.({
+				turnNumber: startTurn + turnsUsed + 1,
+				issuesCount: scopedIssues.length
+			});
+		} catch {}
+		const response = await agent.fillFormTool(scopedIssues, form, maxPatchesPerTurn, previousRejections);
+		if (response.patches.length > 0) {
+			const applyResult = applyPatches(form, response.patches);
+			patchesApplied += applyResult.appliedPatches.length;
+			previousRejections = applyResult.rejectedPatches;
+		} else previousRejections = void 0;
+		turnsUsed++;
+		try {
+			const postInspect = inspect(form, { targetRoles });
+			const requiredIssues = postInspect.issues.filter((i) => i.severity === "required");
+			options.callbacks?.onTurnComplete?.({
+				turnNumber: startTurn + turnsUsed,
+				issuesShown: scopedIssues.length,
+				patchesApplied: response.patches.length,
+				requiredIssuesRemaining: requiredIssues.length,
+				isComplete: postInspect.isComplete,
+				stats: response.stats,
+				issues: scopedIssues,
+				patches: response.patches,
+				rejectedPatches: previousRejections ?? []
+			});
+		} catch {}
+	}
+	return {
+		patchesApplied,
+		turnsUsed,
+		aborted: false
+	};
+}
 
 //#endregion
 //#region src/harness/harnessConfigResolver.ts
@@ -8924,6 +9857,7 @@ function resolveHarnessConfig(form, options) {
 		maxTurns: options?.maxTurnsTotal ?? frontmatterConfig?.maxTurns ?? DEFAULT_MAX_TURNS,
 		maxPatchesPerTurn: options?.maxPatchesPerTurn ?? frontmatterConfig?.maxPatchesPerTurn ?? DEFAULT_MAX_PATCHES_PER_TURN,
 		maxIssuesPerTurn: options?.maxIssuesPerTurn ?? frontmatterConfig?.maxIssuesPerTurn ?? DEFAULT_MAX_ISSUES_PER_TURN,
+		maxParallelAgents: options?.maxParallelAgents ?? frontmatterConfig?.maxParallelAgents ?? DEFAULT_MAX_PARALLEL_AGENTS,
 		targetRoles: options?.targetRoles,
 		fillMode: options?.fillMode
 	};
@@ -9048,8 +9982,8 @@ function validateResearchForm(form) {
 //#endregion
 //#region src/index.ts
 /** Markform version (injected at build time). */
-const VERSION = "0.1.16";
+const VERSION = "0.1.18";
 
 //#endregion
-export { parseRawTable as A, parseScopeRef as C, parseForm as D, formToJsonSchema as E, parseCellValue as O, isQualifiedRef as S, fieldToJsonSchema as T, coerceToFieldPatch as _, resolveHarnessConfig as a, isCellRef as b, getProviderNames as c, createLiveAgent as d, MockAgent as f, coerceInputContext as g, createHarness as h, runResearch as i, parseMarkdownTable as k, resolveModel as l, FormHarness as m, isResearchForm as n, fillForm as o, createMockAgent as p, validateResearchForm as r, getProviderInfo as s, VERSION as t, buildMockWireFormat as u, findFieldById as v, serializeScopeRef as w, isFieldRef as x, getFieldId as y };
-//# sourceMappingURL=src-Dv3IZSQU.mjs.map
+export { formToJsonSchema as A, getFieldId as C, parseScopeRef as D, isQualifiedRef as E, findAllHeadings as F, findEnclosingHeadings as I, parseCellValue as L, findAllCheckboxes as M, injectCheckboxIds as N, serializeScopeRef as O, injectHeaderIds as P, parseMarkdownTable as R, findFieldById as S, isFieldRef as T, createMockAgent as _, resolveHarnessConfig as a, coerceInputContext as b, createParallelHarness as c, getProviderNames as d, resolveModel as f, MockAgent as g, computeExecutionPlan as h, runResearch as i, parseForm as j, fieldToJsonSchema as k, scopeIssuesForItem as l, createLiveAgent as m, isResearchForm as n, fillForm as o, buildMockWireFormat as p, validateResearchForm as r, ParallelHarness as s, VERSION as t, getProviderInfo as u, FormHarness as v, isCellRef as w, coerceToFieldPatch as x, createHarness as y, parseRawTable as z };
+//# sourceMappingURL=src-DDxi-2ne.mjs.map