markform 0.1.22 → 0.1.24

package/dist/{apply-C7mO7VkZ.mjs → prompts-BCnYaH4_.mjs}

@@ -3,7 +3,7 @@ import { n as formatUrlAsMarkdownLink } from "./urlFormat-lls7CsEP.mjs";
 import YAML from "yaml";
 
 //#region src/errors.ts
-const VERSION = "0.1.22";
+const VERSION = "0.1.24";
 /**
 * Base error class for all markform errors.
 * Consumers can catch this to handle any markform error.
@@ -512,6 +512,12 @@ const DEFAULT_MAX_ISSUES_PER_TURN = 10;
 */
 const DEFAULT_MAX_PARALLEL_AGENTS = 4;
 /**
+* Default maximum AI SDK retries for transient API errors (429, 503, etc.).
+* The Vercel AI SDK handles retry with exponential backoff automatically.
+* Set to 0 to disable retries (useful for fast tests).
+*/
+const DEFAULT_MAX_RETRIES = 3;
+/**
 * Default maximum AI SDK steps (tool call rounds) per harness turn.
 * Matches AI SDK's ToolLoopAgent default of 20.
 * @see https://ai-sdk.dev/docs/agents/loop-control
@@ -3772,7 +3778,7 @@ function getAllFields(form) {
 /**
 * Find a field by its ID.
 */
-function findFieldById(form, fieldId) {
+function findFieldById$1(form, fieldId) {
 	for (const group of form.schema.groups) for (const field of group.children) if (field.id === fieldId) return field;
 }
 /**
@@ -3793,7 +3799,7 @@ function getFieldsForRoles(form, targetRoles) {
 * - 'explicit': No options may be 'unfilled'
 */
 function isCheckboxComplete(form, fieldId) {
-	const field = findFieldById(form, fieldId);
+	const field = findFieldById$1(form, fieldId);
 	if (field?.kind !== "checkboxes") return true;
 	const checkboxField = field;
 	const response = form.responsesByFieldId[fieldId];
@@ -3820,7 +3826,7 @@ function findBlockingCheckpoint(form) {
 	for (let i = 0; i < form.orderIndex.length; i++) {
 		const fieldId = form.orderIndex[i];
 		if (!fieldId) continue;
-		const field = findFieldById(form, fieldId);
+		const field = findFieldById$1(form, fieldId);
 		if (field?.kind !== "checkboxes") continue;
 		if (field.approvalMode === "blocking" && !isCheckboxComplete(form, fieldId)) return {
 			index: i,
@@ -3858,7 +3864,7 @@ function filterIssuesByRole(issues, form, targetRoles) {
 	}).filter((issue) => {
 		if (!targetFieldIds) return true;
 		const fieldId = issue.ref.includes(".") ? issue.ref.split(".")[0] ?? issue.ref : issue.ref;
-		return !findFieldById(form, fieldId) || targetFieldIds.has(fieldId);
+		return !findFieldById$1(form, fieldId) || targetFieldIds.has(fieldId);
 	});
 }
 
@@ -3876,7 +3882,13 @@ const PATCH_OP_TO_FIELD_KIND = {
 	set_url_list: "url_list",
 	set_date: "date",
 	set_year: "year",
-	set_table: "table"
+	set_table: "table",
+	append_table: "table",
+	delete_table: "table",
+	append_string_list: "string_list",
+	delete_string_list: "string_list",
+	append_url_list: "url_list",
+	delete_url_list: "url_list"
 };
 /**
 * Find a field by ID in the form schema.
@@ -4101,6 +4113,43 @@ function validatePatch(form, patch, index) {
 				message: `Invalid column "${colId}" for table field "${field.id}"`
 			};
 		}
+	} else if (patch.op === "append_table" && field.kind === "table") {
+		const columnIds = field.columns.map((c) => c.id);
+		if (!Array.isArray(patch.value)) return {
+			patchIndex: index,
+			message: `Invalid append_table patch for field "${field.id}": value must be an array of row objects. Columns: [${columnIds.join(", ")}]`,
+			fieldId: field.id,
+			fieldKind: field.kind,
+			columnIds
+		};
+		const validColumns = new Set(columnIds);
+		for (const row of patch.value) if (row != null) {
+			for (const colId of Object.keys(row)) if (!validColumns.has(colId)) return {
+				patchIndex: index,
+				message: `Invalid column "${colId}" for table field "${field.id}"`
+			};
+		}
+	} else if (patch.op === "delete_table" && field.kind === "table") {
+		const currentValue = form.responsesByFieldId[field.id]?.value;
+		const rowCount = currentValue?.kind === "table" ? currentValue.rows.length : 0;
+		if (patch.value >= rowCount) return {
+			patchIndex: index,
+			message: `Index ${patch.value} out of bounds for table field "${field.id}" (${rowCount} rows)`
+		};
+	} else if ((patch.op === "append_string_list" || patch.op === "append_url_list") && (field.kind === "string_list" || field.kind === "url_list")) {
+		if (!Array.isArray(patch.value)) return {
+			patchIndex: index,
+			message: `Invalid ${patch.op} patch for field "${field.id}": value must be an array`,
+			fieldId: field.id,
+			fieldKind: field.kind
+		};
+	} else if ((patch.op === "delete_string_list" || patch.op === "delete_url_list") && (field.kind === "string_list" || field.kind === "url_list")) {
+		const currentValue = form.responsesByFieldId[field.id]?.value;
+		const itemCount = currentValue?.kind === "string_list" || currentValue?.kind === "url_list" ? currentValue.items.length : 0;
+		if (patch.value >= itemCount) return {
+			patchIndex: index,
+			message: `Index ${patch.value} out of bounds for ${field.kind} field "${field.id}" (${itemCount} items)`
+		};
 	} else if (patch.op === "skip_field" && field.required) return {
 		patchIndex: index,
 		message: `Cannot skip required field "${field.id}"`
@@ -4247,6 +4296,86 @@ function applyPatch(form, responses, patch) {
 			};
 			break;
 		}
+		case "append_table": {
+			const existing = responses[patch.fieldId]?.value;
+			const currentRows = existing?.kind === "table" ? [...existing.rows] : [];
+			const newRows = (patch.value ?? []).map((patchRow) => {
+				const row = {};
+				if (patchRow != null) for (const [colId, cellValue] of Object.entries(patchRow)) row[colId] = patchValueToCell(cellValue);
+				return row;
+			});
+			responses[patch.fieldId] = {
+				state: "answered",
+				value: {
+					kind: "table",
+					rows: [...currentRows, ...newRows]
+				}
+			};
+			break;
+		}
+		case "delete_table": {
+			const existingTbl = responses[patch.fieldId]?.value;
+			const rows = existingTbl?.kind === "table" ? [...existingTbl.rows] : [];
+			rows.splice(patch.value, 1);
+			responses[patch.fieldId] = {
+				state: rows.length > 0 ? "answered" : "unanswered",
+				...rows.length > 0 && { value: {
+					kind: "table",
+					rows
+				} }
+			};
+			break;
+		}
+		case "append_string_list": {
+			const existingList = responses[patch.fieldId]?.value;
+			const currentItems = existingList?.kind === "string_list" ? [...existingList.items] : [];
+			responses[patch.fieldId] = {
+				state: "answered",
+				value: {
+					kind: "string_list",
+					items: [...currentItems, ...patch.value]
+				}
+			};
+			break;
+		}
+		case "delete_string_list": {
+			const existingSl = responses[patch.fieldId]?.value;
+			const items = existingSl?.kind === "string_list" ? [...existingSl.items] : [];
+			items.splice(patch.value, 1);
+			responses[patch.fieldId] = {
+				state: items.length > 0 ? "answered" : "unanswered",
+				...items.length > 0 && { value: {
+					kind: "string_list",
+					items
+				} }
+			};
+			break;
+		}
+		case "append_url_list": {
+			const existingUl = responses[patch.fieldId]?.value;
+			const currentUrls = existingUl?.kind === "url_list" ? [...existingUl.items] : [];
+			responses[patch.fieldId] = {
+				state: "answered",
+				value: {
+					kind: "url_list",
+					items: [...currentUrls, ...patch.value]
+				}
+			};
+			break;
+		}
+		case "delete_url_list": {
+			const existingUlDel = responses[patch.fieldId]?.value;
+			const urls = existingUlDel?.kind === "url_list" ? [...existingUlDel.items] : [];
+			urls.splice(patch.value, 1);
+			responses[patch.fieldId] = {
+				state: urls.length > 0 ? "answered" : "unanswered",
+				...urls.length > 0 && { value: {
+					kind: "url_list",
+					items: urls
+				} }
+			};
+			break;
+		}
 		case "clear_field":
 			responses[patch.fieldId] = { state: "unanswered" };
 			break;
@@ -4356,5 +4485,837 @@ function applyPatches(form, patches) {
 }
 
 //#endregion
-export { WEB_SEARCH_CONFIG as $, DEFAULT_FORMS_DIR as A, DEFAULT_ROLES as B, getNumberAttr as C, isTagNode as D, getValidateAttr as E, DEFAULT_MAX_TURNS as F, deriveExportPath as G, MAX_FORMS_IN_MENU as H, DEFAULT_PORT as I, deriveSchemaPath as J, deriveFillRecordPath as K, DEFAULT_PRIORITY as L, DEFAULT_MAX_PARALLEL_AGENTS as M, DEFAULT_MAX_PATCHES_PER_TURN as N, parseOptionText as O, DEFAULT_MAX_STEPS_PER_TURN as P, SUGGESTED_LLMS as Q, DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN as R, getBooleanAttr as S, getStringAttr as T, REPORT_EXTENSION as U, DEFAULT_ROLE_INSTRUCTIONS as V, USER_ROLE as W, parseRolesFlag as X, detectFileType as Y, transformHarnessConfigToTs as Z, tryParseSentinelResponse as _, isPatchError as _t, validate as a, MarkformConfigError as at, extractOptionItems as b, wrapApiError as bt, computeProgressSummary as c, MarkformParseError as ct, serializeForm as d, ParseError as dt, formatSuggestedLlms as et, serializeRawMarkdown as f, isAbortError as ft, validateSyntaxConsistency as g, isParseError as gt, preprocessCommentSyntax as h, isMarkformError as ht, inspect as i, MarkformAbortError as it, DEFAULT_MAX_ISSUES_PER_TURN as j, AGENT_ROLE as k, computeStructureSummary as l, MarkformPatchError as lt, detectSyntaxStyle as m, isLlmError as mt, getAllFields as n, hasWebSearchSupport as nt, computeAllSummaries as o, MarkformError as ot, serializeReport as p, isConfigError as pt, deriveReportPath as q, getFieldsForRoles as r, parseModelIdForDisplay as rt, computeFormState as s, MarkformLlmError as st, applyPatches as t, getWebSearchConfig as tt, isFormComplete as u, MarkformValidationError as ut, CHECKBOX_MARKERS as v, isRetryableError as vt, getStringArrayAttr as w, extractTableContent as x, extractFenceValue as y, isValidationError as yt, DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN as z };
-//# sourceMappingURL=apply-C7mO7VkZ.mjs.map
+//#region src/engine/valueCoercion.ts
+/**
+* Find a field by ID.
+*
+* Uses idIndex for O(1) validation that the ID exists and is a field,
+* then retrieves the Field object from the schema.
+*/
+function findFieldById(form, fieldId) {
+	if (form.idIndex.get(fieldId)?.nodeType !== "field") return;
+	for (const group of form.schema.groups) for (const field of group.children) if (field.id === fieldId) return field;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function coerceToString(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_string",
+			fieldId,
+			value: null
+		}
+	};
+	if (typeof rawValue === "string") return {
+		ok: true,
+		patch: {
+			op: "set_string",
+			fieldId,
+			value: rawValue
+		}
+	};
+	if (typeof rawValue === "number") return {
+		ok: true,
+		patch: {
+			op: "set_string",
+			fieldId,
+			value: String(rawValue)
+		},
+		warning: `Coerced number ${rawValue} to string for field '${fieldId}'`
+	};
+	if (typeof rawValue === "boolean") return {
+		ok: true,
+		patch: {
+			op: "set_string",
+			fieldId,
+			value: String(rawValue)
+		},
+		warning: `Coerced boolean ${rawValue} to string for field '${fieldId}'`
+	};
+	return {
+		ok: false,
+		error: `Cannot coerce ${typeof rawValue} to string for field '${fieldId}'`
+	};
+}
+function coerceToNumber(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_number",
+			fieldId,
+			value: null
+		}
+	};
+	if (typeof rawValue === "number") return {
+		ok: true,
+		patch: {
+			op: "set_number",
+			fieldId,
+			value: rawValue
+		}
+	};
+	if (typeof rawValue === "string") {
+		const parsed = Number(rawValue);
+		if (!Number.isNaN(parsed)) return {
+			ok: true,
+			patch: {
+				op: "set_number",
+				fieldId,
+				value: parsed
+			},
+			warning: `Coerced string '${rawValue}' to number for field '${fieldId}'`
+		};
+		return {
+			ok: false,
+			error: `Cannot coerce non-numeric string '${rawValue}' to number for field '${fieldId}'`
+		};
+	}
+	return {
+		ok: false,
+		error: `Cannot coerce ${typeof rawValue} to number for field '${fieldId}'`
+	};
+}
+function coerceToStringList(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_string_list",
+			fieldId,
+			value: []
+		}
+	};
+	if (isStringArray(rawValue)) return {
+		ok: true,
+		patch: {
+			op: "set_string_list",
+			fieldId,
+			value: rawValue
+		}
+	};
+	if (typeof rawValue === "string") return {
+		ok: true,
+		patch: {
+			op: "set_string_list",
+			fieldId,
+			value: [rawValue]
+		},
+		warning: `Coerced single string to array for field '${fieldId}'`
+	};
+	if (Array.isArray(rawValue)) {
+		const items = [];
+		for (const item of rawValue) if (typeof item === "string") items.push(item);
+		else if (typeof item === "number" || typeof item === "boolean") items.push(String(item));
+		else return {
+			ok: false,
+			error: `Cannot coerce array with non-string items to string_list for field '${fieldId}'`
+		};
+		return {
+			ok: true,
+			patch: {
+				op: "set_string_list",
+				fieldId,
+				value: items
+			},
+			warning: `Coerced array items to strings for field '${fieldId}'`
+		};
+	}
+	return {
+		ok: false,
+		error: `Cannot coerce ${typeof rawValue} to string_list for field '${fieldId}'`
+	};
+}
+function coerceToSingleSelect(field, rawValue) {
+	if (field.kind !== "single_select") return {
+		ok: false,
+		error: `Field '${field.id}' is not a single_select field`
+	};
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_single_select",
+			fieldId: field.id,
+			value: null
+		}
+	};
+	if (typeof rawValue !== "string") return {
+		ok: false,
+		error: `single_select field '${field.id}' requires a string option ID, got ${typeof rawValue}`
+	};
+	const validOptions = new Set(field.options.map((o) => o.id));
+	if (!validOptions.has(rawValue)) return {
+		ok: false,
+		error: `Invalid option '${rawValue}' for single_select field '${field.id}'. Valid options: ${Array.from(validOptions).join(", ")}`
+	};
+	return {
+		ok: true,
+		patch: {
+			op: "set_single_select",
+			fieldId: field.id,
+			value: rawValue
+		}
+	};
+}
+function coerceToMultiSelect(field, rawValue) {
+	if (field.kind !== "multi_select") return {
+		ok: false,
+		error: `Field '${field.id}' is not a multi_select field`
+	};
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_multi_select",
+			fieldId: field.id,
+			value: []
+		}
+	};
+	const validOptions = new Set(field.options.map((o) => o.id));
+	let selected;
+	let warning;
+	if (typeof rawValue === "string") {
+		selected = [rawValue];
+		warning = `Coerced single string to array for multi_select field '${field.id}'`;
+	} else if (isStringArray(rawValue)) selected = rawValue;
+	else return {
+		ok: false,
+		error: `multi_select field '${field.id}' requires a string or string array, got ${typeof rawValue}`
+	};
+	for (const optId of selected) if (!validOptions.has(optId)) return {
+		ok: false,
+		error: `Invalid option '${optId}' for multi_select field '${field.id}'. Valid options: ${Array.from(validOptions).join(", ")}`
+	};
+	const patch = {
+		op: "set_multi_select",
+		fieldId: field.id,
+		value: selected
+	};
+	return warning ? {
+		ok: true,
+		patch,
+		warning
+	} : {
+		ok: true,
+		patch
+	};
+}
+function coerceToCheckboxes(field, rawValue) {
+	if (field.kind !== "checkboxes") return {
+		ok: false,
+		error: `Field '${field.id}' is not a checkboxes field`
+	};
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_checkboxes",
+			fieldId: field.id,
+			value: {}
+		}
+	};
+	const validOptions = new Set(field.options.map((o) => o.id));
+	const checkboxMode = field.checkboxMode;
+	if (Array.isArray(rawValue)) {
+		const defaultState = checkboxMode === "explicit" ? "yes" : "done";
+		const values = {};
+		for (const item of rawValue) {
+			if (typeof item !== "string") return {
+				ok: false,
+				error: `Array items for checkboxes field '${field.id}' must be strings (option IDs), got ${typeof item}`
+			};
+			if (!validOptions.has(item)) return {
+				ok: false,
+				error: `Invalid option '${item}' for checkboxes field '${field.id}'. Valid options: ${Array.from(validOptions).join(", ")}`
+			};
+			values[item] = defaultState;
+		}
+		const patch = {
+			op: "set_checkboxes",
+			fieldId: field.id,
+			value: values
+		};
+		if (rawValue.length === 0) return {
+			ok: true,
+			patch
+		};
+		return {
+			ok: true,
+			patch,
+			warning: `Coerced array to checkboxes object with '${defaultState}' state for field '${field.id}'`
+		};
+	}
+	if (!isPlainObject(rawValue)) return {
+		ok: false,
+		error: `checkboxes field '${field.id}' requires a Record<string, CheckboxValue> or array of option IDs, got ${typeof rawValue}`
+	};
+	const values = {};
+	let hadBooleanCoercion = false;
+	const validValues = new Set(checkboxMode === "explicit" ? [
+		"unfilled",
+		"yes",
+		"no"
+	] : checkboxMode === "simple" ? ["todo", "done"] : [
+		"todo",
+		"done",
+		"incomplete",
+		"active",
+		"na"
+	]);
+	for (const [optId, value] of Object.entries(rawValue)) {
+		if (!validOptions.has(optId)) return {
+			ok: false,
+			error: `Invalid option '${optId}' for checkboxes field '${field.id}'. Valid options: ${Array.from(validOptions).join(", ")}`
+		};
+		if (typeof value === "boolean") {
+			hadBooleanCoercion = true;
+			if (checkboxMode === "explicit") values[optId] = value ? "yes" : "no";
+			else values[optId] = value ? "done" : "todo";
+			continue;
+		}
+		if (typeof value !== "string" || !validValues.has(value)) return {
+			ok: false,
+			error: `Invalid checkbox value '${String(value)}' for option '${optId}' in field '${field.id}'. Valid values for ${checkboxMode} mode: ${Array.from(validValues).join(", ")} (or use true/false)`
+		};
+		values[optId] = value;
+	}
+	const patch = {
+		op: "set_checkboxes",
+		fieldId: field.id,
+		value: values
+	};
+	if (hadBooleanCoercion) return {
+		ok: true,
+		patch,
+		warning: `Coerced boolean values to checkbox strings for field '${field.id}'`
+	};
+	return {
+		ok: true,
+		patch
+	};
+}
+function coerceToUrl(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_url",
+			fieldId,
+			value: null
+		}
+	};
+	if (typeof rawValue === "string") return {
+		ok: true,
+		patch: {
+			op: "set_url",
+			fieldId,
+			value: rawValue
+		}
+	};
+	return {
+		ok: false,
+		error: `Cannot coerce ${typeof rawValue} to url for field '${fieldId}'`
+	};
+}
+function coerceToUrlList(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_url_list",
+			fieldId,
+			value: []
+		}
+	};
+	if (isStringArray(rawValue)) return {
+		ok: true,
+		patch: {
+			op: "set_url_list",
+			fieldId,
+			value: rawValue
+		}
+	};
+	if (typeof rawValue === "string") return {
+		ok: true,
+		patch: {
+			op: "set_url_list",
+			fieldId,
+			value: [rawValue]
+		},
+		warning: `Coerced single string to array for field '${fieldId}'`
+	};
+	if (Array.isArray(rawValue)) {
+		const items = [];
+		for (const item of rawValue) if (typeof item === "string") items.push(item);
+		else return {
+			ok: false,
+			error: `Cannot coerce array with non-string items to url_list for field '${fieldId}'`
+		};
+		return {
+			ok: true,
+			patch: {
+				op: "set_url_list",
+				fieldId,
+				value: items
+			}
+		};
+	}
+	return {
+		ok: false,
+		error: `Cannot coerce ${typeof rawValue} to url_list for field '${fieldId}'`
+	};
+}
+function coerceToDate(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_date",
+			fieldId,
+			value: null
+		}
+	};
+	if (typeof rawValue === "string") return {
+		ok: true,
+		patch: {
+			op: "set_date",
+			fieldId,
+			value: rawValue
+		}
+	};
+	return {
+		ok: false,
+		error: `Cannot coerce ${typeof rawValue} to date for field '${fieldId}'`
+	};
+}
+function coerceToYear(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_year",
+			fieldId,
+			value: null
+		}
+	};
+	if (typeof rawValue === "number") {
+		if (!Number.isInteger(rawValue)) return {
+			ok: false,
+			error: `Year must be an integer for field '${fieldId}', got ${rawValue}`
+		};
+		return {
+			ok: true,
+			patch: {
+				op: "set_year",
+				fieldId,
+				value: rawValue
+			}
+		};
+	}
+	if (typeof rawValue === "string") {
+		const parsed = Number.parseInt(rawValue, 10);
+		if (Number.isNaN(parsed)) return {
+			ok: false,
+			error: `Cannot coerce non-numeric string '${rawValue}' to year for field '${fieldId}'`
+		};
+		return {
+			ok: true,
+			patch: {
+				op: "set_year",
+				fieldId,
+				value: parsed
+			},
+			warning: `Coerced string '${rawValue}' to year for field '${fieldId}'`
+		};
+	}
+	return {
+		ok: false,
+		error: `Cannot coerce ${typeof rawValue} to year for field '${fieldId}'`
+	};
+}
+/**
+* Coerce raw value to SetTablePatch.
+* Accepts:
+* - Array of row objects: [{ col1: value1, col2: value2 }, ...]
+* - Empty array: [] (valid for optional tables or minRows=0)
+*/
+function coerceToTable(fieldId, rawValue) {
+	if (rawValue === null) return {
+		ok: true,
+		patch: {
+			op: "set_table",
+			fieldId,
+			value: []
+		}
+	};
+	if (!Array.isArray(rawValue)) return {
+		ok: false,
+		error: `Table value for field '${fieldId}' must be an array of rows, got ${typeof rawValue}`
+	};
+	if (rawValue.length === 0) return {
+		ok: true,
+		patch: {
+			op: "set_table",
+			fieldId,
+			value: []
+		}
+	};
+	const rows = [];
+	for (let i = 0; i < rawValue.length; i++) {
+		const row = rawValue[i];
+		if (typeof row !== "object" || row === null || Array.isArray(row)) return {
+			ok: false,
+			error: `Row ${i} for table field '${fieldId}' must be an object, got ${Array.isArray(row) ? "array" : typeof row}`
+		};
+		rows.push(row);
+	}
+	return {
+		ok: true,
+		patch: {
+			op: "set_table",
+			fieldId,
+			value: rows
+		}
+	};
+}
+/**
+* Coerce a raw value to a Patch for a specific field.
+*/
+function coerceToFieldPatch(form, fieldId, rawValue) {
+	const field = findFieldById(form, fieldId);
+	if (!field) return {
+		ok: false,
+		error: `Field '${fieldId}' not found`
+	};
+	switch (field.kind) {
+		case "string": return coerceToString(fieldId, rawValue);
+		case "number": return coerceToNumber(fieldId, rawValue);
+		case "string_list": return coerceToStringList(fieldId, rawValue);
+		case "single_select": return coerceToSingleSelect(field, rawValue);
+		case "multi_select": return coerceToMultiSelect(field, rawValue);
+		case "checkboxes": return coerceToCheckboxes(field, rawValue);
+		case "url": return coerceToUrl(fieldId, rawValue);
+		case "url_list": return coerceToUrlList(fieldId, rawValue);
+		case "date": return coerceToDate(fieldId, rawValue);
+		case "year": return coerceToYear(fieldId, rawValue);
+		case "table": return coerceToTable(fieldId, rawValue);
+		default: {
+			const _exhaustive = field;
+			throw new Error(`Unhandled field kind: ${_exhaustive.kind}`);
+		}
+	}
+}
+/**
+* Coerce an entire InputContext to patches.
+*
+* Returns patches for valid entries, collects warnings for coercions,
+* and errors for invalid entries.
+*/
+function coerceInputContext(form, inputContext) {
+	const patches = [];
+	const warnings = [];
+	const errors = [];
+	for (const [fieldId, rawValue] of Object.entries(inputContext)) {
+		if (rawValue === null) continue;
+		const result = coerceToFieldPatch(form, fieldId, rawValue);
+		if (result.ok) {
+			patches.push(result.patch);
+			if ("warning" in result && result.warning) warnings.push(result.warning);
+		} else errors.push(result.error);
+	}
+	return {
+		patches,
+		warnings,
+		errors
+	};
+}
+
+//#endregion
+//#region src/engine/issueFiltering.ts
+/**
+* Extract field ID from an issue ref based on its scope.
+*
+* - field scope: ref IS the fieldId
+* - option/column/cell scope: ref is "fieldId.subId" — extract the prefix
+* - form/group scope: no field ID available
+*/
+function getFieldIdFromRef(ref, scope) {
+	if (scope === "field") return ref;
+	if (scope === "option" || scope === "column" || scope === "cell") {
+		const dotIndex = ref.indexOf(".");
+		return dotIndex > 0 ? ref.slice(0, dotIndex) : void 0;
+	}
+}
+/**
+* Get the parent group ID for a field from the form's ID index.
+*/
+function getGroupForField(form, fieldId) {
+	const entry = form.idIndex.get(fieldId);
+	if (!entry) return;
+	if (entry.parentId) {
+		if (form.idIndex.get(entry.parentId)?.nodeType === "group") return entry.parentId;
+	}
+}
+/**
+* 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).
+*/
+function filterIssuesByOrder(issues, form) {
+	const fieldOrderMap = /* @__PURE__ */ new Map();
+	for (const group of 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 = 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 = getFieldIdFromRef(issue.ref, issue.scope);
+		if (!fieldId) return true;
+		return (fieldOrderMap.get(fieldId) ?? 0) === currentOrder;
+	});
+}
+/**
+* Filter issues based on maxFields and maxGroups limits.
+*
+* Issues are processed in priority order. An issue is included if:
+* - Adding it doesn't exceed the field limit (for field/option scoped issues)
+* - Adding it doesn't exceed the group limit
+*
+* Form-level issues are always included.
+*/
+function filterIssuesByScope(issues, form, maxFields, maxGroups) {
+	if (maxFields === void 0 && maxGroups === void 0) return issues;
+	const result = [];
+	const seenFields = /* @__PURE__ */ new Set();
+	const seenGroups = /* @__PURE__ */ new Set();
+	for (const issue of issues) {
+		if (issue.scope === "form") {
+			result.push(issue);
+			continue;
+		}
+		const fieldId = getFieldIdFromRef(issue.ref, issue.scope);
+		const groupId = fieldId ? getGroupForField(form, fieldId) : void 0;
+		if (maxFields !== void 0 && fieldId) {
+			if (!seenFields.has(fieldId) && seenFields.size >= maxFields) continue;
+		}
+		if (maxGroups !== void 0 && groupId) {
+			if (!seenGroups.has(groupId) && seenGroups.size >= maxGroups) continue;
+		}
+		result.push(issue);
+		if (fieldId) seenFields.add(fieldId);
+		if (groupId) seenGroups.add(groupId);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/harness/prompts.ts
+/**
+* Agent Prompts - Centralized prompt definitions for the live agent.
+*
+* All hardcoded prompts are defined here for easy review, modification,
+* and future configurability. This file serves as the single source of
+* truth for agent behavior instructions.
+*/
+/**
+* Default system prompt for the live agent.
+*
+* This is the base instruction set that defines the agent's core behavior
+* for form filling. It emphasizes accuracy over completeness and prohibits
+* fabrication of data.
+*/
+const DEFAULT_SYSTEM_PROMPT = `# Form Instructions
+
+Research and fill the form fields using all available tools. Focus on accuracy over completeness.
+
+## Guidelines
+1. Address required fields first (severity: "required"), then optional fields (severity: "recommended")
+2. NEVER fabricate or guess information - only use data you can verify
+3. If you cannot find verifiable information, use skip_field with a reason
+
+## Patch Format Examples
+
+Use the fill_form tool with patches in these formats:
+
+| Type | Example |
+|------|---------|
+| string | \`{ op: "set_string", fieldId: "name", value: "Acme Corp" }\` |
+| number | \`{ op: "set_number", fieldId: "age", value: 32 }\` |
+| string_list | \`{ op: "set_string_list", fieldId: "tags", value: ["ai", "ml"] }\` |
+| url | \`{ op: "set_url", fieldId: "website", value: "https://example.com" }\` |
+| url_list | \`{ op: "set_url_list", fieldId: "sources", value: ["https://a.com", "https://b.com"] }\` |
+| date | \`{ op: "set_date", fieldId: "event_date", value: "2024-06-15" }\` |
+| year | \`{ op: "set_year", fieldId: "founded", value: 2024 }\` |
+| single_select | \`{ op: "set_single_select", fieldId: "priority", value: "high" }\` |
+| multi_select | \`{ op: "set_multi_select", fieldId: "categories", value: ["frontend", "backend"] }\` |
+| checkboxes | \`{ op: "set_checkboxes", fieldId: "tasks", value: { "task1": "done", "task2": "todo" } }\` |
+| table | \`{ op: "set_table", fieldId: "team", value: [{ "name": "Alice", "role": "Engineer" }] }\` |
+
+## Incremental Operations (for collections)
+
+Use these to add/remove items without replacing the entire collection:
+
+| Type | Example |
+|------|---------|
+| append_table | \`{ op: "append_table", fieldId: "team", value: [{ "name": "Bob", "role": "PM" }] }\` |
+| append_string_list | \`{ op: "append_string_list", fieldId: "tags", value: ["new_tag"] }\` |
+| append_url_list | \`{ op: "append_url_list", fieldId: "sources", value: ["https://new.com"] }\` |
+| delete_table | \`{ op: "delete_table", fieldId: "team", value: 0 }\` (0-based row index) |
+| delete_string_list | \`{ op: "delete_string_list", fieldId: "tags", value: 0 }\` (0-based item index) |
+| delete_url_list | \`{ op: "delete_url_list", fieldId: "sources", value: 0 }\` (0-based item index) |
+
+## Important: checkboxes vs multi_select
+
+These two types look similar but have DIFFERENT value formats:
+
+- **multi_select** → array of option IDs: \`["opt1", "opt2"]\`
+- **checkboxes** → object mapping IDs to states: \`{ "opt1": "done", "opt2": "todo" }\`
+
+**Checkbox states by mode:**
+- Mode "simple": \`"done"\` or \`"todo"\`
+- Mode "multi": \`"done"\`, \`"todo"\`, \`"incomplete"\`, \`"active"\`, or \`"na"\`
+- Mode "explicit": \`"yes"\` or \`"no"\` (if unknown, use abort_field)
+
+**WRONG:** \`{ op: "set_checkboxes", value: ["task1", "task2"] }\`
+**RIGHT:** \`{ op: "set_checkboxes", value: { "task1": "done", "task2": "done" } }\`
+
+## Skipping Fields
+
+If you cannot find verifiable information:
+\`{ op: "skip_field", fieldId: "...", reason: "Could not find verified data" }\`
+`;
+/**
+* Web search instructions appended when web search tools are available.
+*
+* These instructions enforce that the agent must verify all information
+* through web search before filling fields.
+*/
+const WEB_SEARCH_INSTRUCTIONS = `# Web Search
+You have access to web search tools. You MUST use them to verify ALL information before filling fields.
+
+Guidelines:
+1. Search for official sources (company websites, Crunchbase, LinkedIn, press releases)
+2. Cross-reference information across multiple sources when possible
+3. Only fill fields with data you found and verified through search
+4. If a search returns no results or uncertain information, use skip_field with a reason explaining what you searched for
+5. NEVER fill fields with guessed or assumed information
+`;
+/**
+* Header for the issues section in the context prompt.
+*/
+const ISSUES_HEADER = "# Current Form Issues";
+/**
+* Template for the issues intro text.
+* @param issueCount - Actual number of issues shown
+*/
+function getIssuesIntro(issueCount) {
+	return `You need to address ${issueCount} issue${issueCount === 1 ? "" : "s"}. Here are the current issues:`;
+}
+/**
+* Patch format examples by field kind.
+*
+* This is the single source of truth for patch format documentation.
+* Used in PATCH_FORMAT_INSTRUCTIONS and rejection feedback hints.
+*/
+const PATCH_FORMATS = {
+	string: "{ op: \"set_string\", fieldId: \"...\", value: \"text here\" }",
+	number: "{ op: \"set_number\", fieldId: \"...\", value: 42 }",
+	string_list: "{ op: \"set_string_list\", fieldId: \"...\", value: [\"item1\", \"item2\"] }",
+	single_select: "{ op: \"set_single_select\", fieldId: \"...\", value: \"option_id\" }",
+	multi_select: "{ op: \"set_multi_select\", fieldId: \"...\", value: [\"opt1\", \"opt2\"] }",
+	checkboxes: "{ op: \"set_checkboxes\", fieldId: \"...\", value: { \"opt1\": \"done\", \"opt2\": \"todo\" } }",
+	url: "{ op: \"set_url\", fieldId: \"...\", value: \"https://example.com\" }",
+	url_list: "{ op: \"set_url_list\", fieldId: \"...\", value: [\"https://a.com\", \"https://b.com\"] }",
+	date: "{ op: \"set_date\", fieldId: \"...\", value: \"2024-06-15\" }",
+	year: "{ op: \"set_year\", fieldId: \"...\", value: 2024 }",
+	table: "{ op: \"set_table\", fieldId: \"...\", value: [{ col1: \"val1\", col2: \"val2\" }] }",
+	append_table: "{ op: \"append_table\", fieldId: \"...\", value: [{ col1: \"val1\", col2: \"val2\" }] }",
+	append_string_list: "{ op: \"append_string_list\", fieldId: \"...\", value: [\"new_item\"] }",
+	append_url_list: "{ op: \"append_url_list\", fieldId: \"...\", value: [\"https://new.com\"] }",
+	delete_table: "{ op: \"delete_table\", fieldId: \"...\", value: 0 }",
+	delete_string_list: "{ op: \"delete_string_list\", fieldId: \"...\", value: 0 }",
+	delete_url_list: "{ op: \"delete_url_list\", fieldId: \"...\", value: 0 }"
+};
+/**
+* Get the correct patch format for a field kind.
+*
+* @param fieldKind - The field kind (e.g., "table", "string")
+* @param options - Optional configuration for the hint
+* @returns The patch format example string
+*/
+function getPatchFormatHint(fieldKind, fieldIdOrOptions, columnIds) {
+	let options = {};
+	if (typeof fieldIdOrOptions === "string") options = {
+		fieldId: fieldIdOrOptions,
+		columnIds
+	};
+	else if (fieldIdOrOptions) options = fieldIdOrOptions;
+	let format = PATCH_FORMATS[fieldKind];
+	if (!format) return `Use the correct set_${fieldKind} operation for this field type.`;
+	if (options.fieldId) format = format.replace("fieldId: \"...\"", `fieldId: "${options.fieldId}"`);
+	if (fieldKind === "checkboxes") {
+		const mode = options.checkboxMode ?? "multi";
+		const optIds = options.optionIds ?? ["opt1", "opt2"];
+		const [state1, state2] = {
+			simple: ["done", "todo"],
+			multi: ["done", "todo"],
+			explicit: ["yes", "no"]
+		}[mode] ?? ["done", "todo"];
+		const valueExample = optIds.length >= 2 ? `{ "${optIds[0]}": "${state1}", "${optIds[1]}": "${state2}" }` : optIds.length === 1 ? `{ "${optIds[0]}": "${state1}" }` : `{ "opt1": "${state1}", "opt2": "${state2}" }`;
+		format = format.replace("{ \"opt1\": \"done\", \"opt2\": \"todo\" }", valueExample);
+	}
+	if ((fieldKind === "table" || fieldKind === "append_table") && options.columnIds && options.columnIds.length > 0) {
+		const colExample = options.columnIds.map((id) => `"${id}": "..."`).join(", ");
+		format = format.replace("{ col1: \"val1\", col2: \"val2\" }", `{ ${colExample} }`);
+	}
+	return format;
+}
+/**
+* Instructions section for the context prompt.
+*
+* This explains the patch format for each field kind.
+* Generated from PATCH_FORMATS to ensure consistency.
+*/
+const PATCH_FORMAT_INSTRUCTIONS = `# Instructions
+
+Use the fill_form tool to submit patches for the fields above.
+Each patch should match the field kind:
+${Object.entries(PATCH_FORMATS).map(([kind, format]) => `- ${kind}: ${format}`).join("\n")}
+
+For table fields, use the column IDs shown in the field schema. Each row is an object with column ID keys.
+
+If you cannot find verifiable information for a field, skip it:
+- skip: { op: "skip_field", fieldId: "...", reason: "Information not available" }`;
+/**
+* Simplified general instructions for use with inline field instructions.
+*
+* When inline field instructions are shown after each issue, we only need
+* general guidance about using the fill_form tool.
+*/
+const GENERAL_INSTRUCTIONS = `# General Instructions
+
+Use the fill_form tool to submit patches for the fields above.
+For table fields, each row is an object with column ID keys.`;
+/**
+* Section headers used when building the composed system prompt.
+*/
+const SECTION_HEADERS = {
+	formInstructions: "# Form Instructions",
+	roleInstructions: (role) => `# Instructions for ${role} role`,
+	roleGuidance: "# Role guidance",
+	fieldInstructions: "# Field-specific instructions",
+	additionalContext: "# Additional Context"
+};
+
+//#endregion
+export { DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN as $, tryParseSentinelResponse as A, isParseError as At, isTagNode as B, isFormComplete as C, MarkformPatchError as Ct, detectSyntaxStyle as D, isConfigError as Dt, serializeReport as E, isAbortError as Et, getBooleanAttr as F, DEFAULT_MAX_PARALLEL_AGENTS as G, AGENT_ROLE as H, getNumberAttr as I, DEFAULT_MAX_STEPS_PER_TURN as J, DEFAULT_MAX_PATCHES_PER_TURN as K, getStringArrayAttr as L, extractFenceValue as M, isRetryableError as Mt, extractOptionItems as N, isValidationError as Nt, preprocessCommentSyntax as O, isLlmError as Ot, extractTableContent as P, wrapApiError as Pt, DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN as Q, getStringAttr as R, computeStructureSummary as S, MarkformParseError as St, serializeRawMarkdown as T, ParseError as Tt, DEFAULT_FORMS_DIR as U, parseOptionText as V, DEFAULT_MAX_ISSUES_PER_TURN as W, DEFAULT_PORT as X, DEFAULT_MAX_TURNS as Y, DEFAULT_PRIORITY as Z, inspect as _, parseModelIdForDisplay as _t, WEB_SEARCH_INSTRUCTIONS as a, deriveExportPath as at, computeFormState as b, MarkformError as bt, filterIssuesByOrder as c, deriveSchemaPath as ct, coerceInputContext as d, transformHarnessConfigToTs as dt, DEFAULT_ROLES as et, coerceToFieldPatch as f, SUGGESTED_LLMS as ft, getFieldsForRoles as g, hasWebSearchSupport as gt, getAllFields as h, getWebSearchConfig as ht, SECTION_HEADERS as i, USER_ROLE as it, CHECKBOX_MARKERS as j, isPatchError as jt, validateSyntaxConsistency as k, isMarkformError as kt, filterIssuesByScope as l, detectFileType as lt, applyPatches as m, formatSuggestedLlms as mt, GENERAL_INSTRUCTIONS as n, MAX_FORMS_IN_MENU as nt, getIssuesIntro as o, deriveFillRecordPath as ot, findFieldById as p, WEB_SEARCH_CONFIG as pt, DEFAULT_MAX_RETRIES as q, ISSUES_HEADER as r, REPORT_EXTENSION as rt, getPatchFormatHint as s, deriveReportPath as st, DEFAULT_SYSTEM_PROMPT as t, DEFAULT_ROLE_INSTRUCTIONS as tt, getFieldIdFromRef as u, parseRolesFlag as ut, validate as v, MarkformAbortError as vt, serializeForm as w, MarkformValidationError as wt, computeProgressSummary as x, MarkformLlmError as xt, computeAllSummaries as y, MarkformConfigError as yt, getValidateAttr as z };
+//# sourceMappingURL=prompts-BCnYaH4_.mjs.map