markform 0.1.14 → 0.1.16

package/dist/{apply-CUH_16RD.mjs → apply-CXsI5N9x.mjs}

@@ -2,7 +2,7 @@
 import YAML from "yaml";
 
 //#region src/errors.ts
-const VERSION = "0.1.14";
+const VERSION = "0.1.16";
 /**
 * Base error class for all markform errors.
 * Consumers can catch this to handle any markform error.
@@ -467,6 +467,457 @@ function deriveSchemaPath(basePath) {
 	return base + SCHEMA_EXTENSION;
 }
 
+//#endregion
+//#region src/engine/preprocess.ts
+const MARKFORM_TAGS = new Set([
+	"form",
+	"field",
+	"group",
+	"note",
+	"instructions",
+	"description"
+]);
+/**
+* Check if a string starts with a known Markform tag name.
+* Returns the tag name if found, null otherwise.
+*/
+function startsWithMarkformTag(content) {
+	const trimmed = content.trim();
+	for (const tag of MARKFORM_TAGS) if (trimmed === tag || trimmed.startsWith(tag + " ") || trimmed.startsWith(tag + "/")) return tag;
+	return null;
+}
+/**
+* Check if content represents a valid form tag with id= attribute.
+* A valid form tag must:
+* - Start with "form " (the tag name followed by space for attributes)
+* - Include an `id=` attribute in any valid Markdoc syntax:
+*   - Double quotes: id="value"
+*   - Single quotes: id='value'
+*   - Unquoted: id=value
+*   - Expression: id={variable}
+*   - With spaces: id = "value"
+*/
+function isValidFormTag(content) {
+	const trimmed = content.trim();
+	if (!trimmed.startsWith("form ")) return false;
+	return trimmed.includes("=") && /\bid\s*=/.test(trimmed);
+}
+/** Parser state for tracking code blocks */
+var State = /* @__PURE__ */ function(State$1) {
+	State$1[State$1["NORMAL"] = 0] = "NORMAL";
+	State$1[State$1["FENCED_CODE"] = 1] = "FENCED_CODE";
+	return State$1;
+}(State || {});
+/**
+* Check if position is at the start of a line (or at position 0).
+*/
+function isAtLineStart(input, pos) {
+	return pos === 0 || input[pos - 1] === "\n";
+}
+/**
+* Check if position is in leading whitespace of a line.
+* Returns true if all characters between the last newline (or start) and pos are spaces.
+*/
+function isInLeadingWhitespace(input, pos) {
+	let j = pos - 1;
+	while (j >= 0 && input[j] !== "\n") {
+		if (input[j] !== " " && input[j] !== "	") return false;
+		j--;
+	}
+	return true;
+}
+/**
+* Match a fenced code block opening at the given position.
+* Returns fence info if found, null otherwise.
+* Handles 0-3 leading spaces per CommonMark spec.
+*/
+function matchFenceOpening(input, pos) {
+	let indent = 0;
+	let i = pos;
+	while (i < input.length && input[i] === " ") {
+		indent++;
+		i++;
+	}
+	if (indent >= 4) return null;
+	const fenceChar = input[i];
+	if (fenceChar !== "`" && fenceChar !== "~") return null;
+	let fenceLength = 0;
+	while (i + fenceLength < input.length && input[i + fenceLength] === fenceChar) fenceLength++;
+	if (fenceLength < 3) return null;
+	let endOfLine = i + fenceLength;
+	while (endOfLine < input.length && input[endOfLine] !== "\n") endOfLine++;
+	if (endOfLine < input.length) endOfLine++;
+	return {
+		char: fenceChar,
+		length: fenceLength,
+		fullMatch: input.slice(pos, endOfLine)
+	};
+}
+/**
+* Check if position matches a closing fence for the given opening fence.
+*/
+function matchFenceClosing(input, pos, fenceChar, fenceLength) {
+	let indent = 0;
+	let i = pos;
+	while (indent < 4 && i < input.length && input[i] === " ") {
+		indent++;
+		i++;
+	}
+	if (input[i] !== fenceChar) return false;
+	let closingLength = 0;
+	while (i + closingLength < input.length && input[i + closingLength] === fenceChar) closingLength++;
+	if (closingLength < fenceLength) return false;
+	let afterFence = i + closingLength;
+	while (afterFence < input.length && input[afterFence] !== "\n") {
+		if (input[afterFence] !== " " && input[afterFence] !== "	") return false;
+		afterFence++;
+	}
+	return true;
+}
+/**
+* Find the end of an inline code span starting at the given position.
+* Returns the position after the closing backticks, or -1 if not a valid span.
+*/
+function findInlineCodeEnd(input, pos) {
+	let openCount = 0;
+	let i = pos;
+	while (i < input.length && input[i] === "`") {
+		openCount++;
+		i++;
+	}
+	if (openCount === 0) return -1;
+	while (i < input.length) if (input[i] === "`") {
+		let closeCount = 0;
+		while (i < input.length && input[i] === "`") {
+			closeCount++;
+			i++;
+		}
+		if (closeCount === openCount) return i;
+	} else if (input[i] === "\n") i++;
+	else i++;
+	return -1;
+}
+/**
+* Transform HTML comment syntax to Markdoc syntax.
+*
+* Transformation rules:
+* - The form tag with `id=` is always transformed (establishes Markform document)
+* - Other tags are ONLY transformed when inside the form tag boundaries
+* - Comments outside the form pass through unchanged (prevents collisions)
+*
+* Patterns transformed (when inside form):
+* - `<!-- tagname ... -->` → `{% tagname ... %}`
+* - `<!-- /tagname -->` → `{% /tagname %}`
+* - `<!-- tagname ... /-->` → `{% tagname ... /%}`
+* - `<!-- #id -->` → `{% #id %}`
+* - `<!-- .class -->` → `{% .class %}`
+*
+* Code blocks (fenced and inline) are preserved unchanged.
+*
+* @param input - The markdown content
+* @returns The preprocessed content with Markdoc syntax
+*/
+function preprocessCommentSyntax(input) {
+	let output = "";
+	let state = State.NORMAL;
+	let fenceChar = "";
+	let fenceLength = 0;
+	let i = 0;
+	let insideForm = false;
+	while (i < input.length) switch (state) {
+		case State.NORMAL:
+			if (isAtLineStart(input, i)) {
+				const fence = matchFenceOpening(input, i);
+				if (fence) {
+					state = State.FENCED_CODE;
+					fenceChar = fence.char;
+					fenceLength = fence.length;
+					output += fence.fullMatch;
+					i += fence.fullMatch.length;
+					continue;
+				}
+			}
+			if (input[i] === "`") {
+				let backtickCount = 0;
+				let j = i;
+				while (j < input.length && input[j] === "`") {
+					backtickCount++;
+					j++;
+				}
+				if (!(backtickCount >= 3 && isInLeadingWhitespace(input, i))) {
+					const end = findInlineCodeEnd(input, i);
+					if (end !== -1) {
+						output += input.slice(i, end);
+						i = end;
+						continue;
+					}
+				}
+			}
+			if (input.slice(i, i + 4) === "<!--") {
+				const endComment = input.indexOf("-->", i + 4);
+				if (endComment !== -1) {
+					const interior = input.slice(i + 4, endComment).trim();
+					if (isValidFormTag(interior)) {
+						if (interior.endsWith("/")) output += "{% " + interior.slice(0, -1).trim() + " /%}";
+						else {
+							output += "{% " + interior + " %}";
+							insideForm = true;
+						}
+						i = endComment + 3;
+						continue;
+					}
+					if (interior === "/form" || interior.startsWith("/form ")) {
+						output += "{% " + interior + " %}";
+						insideForm = false;
+						i = endComment + 3;
+						continue;
+					}
+					if (insideForm) {
+						const tagName = startsWithMarkformTag(interior);
+						if (tagName && tagName !== "form") {
+							if (interior.endsWith("/")) output += "{% " + interior.slice(0, -1).trim() + " /%}";
+							else output += "{% " + interior + " %}";
+							i = endComment + 3;
+							continue;
+						}
+						if (interior.startsWith("/")) {
+							if (startsWithMarkformTag(interior.slice(1))) {
+								output += "{% " + interior + " %}";
+								i = endComment + 3;
+								continue;
+							}
+						}
+						if (interior.startsWith("#") || interior.startsWith(".")) {
+							output += "{% " + interior + " %}";
+							i = endComment + 3;
+							continue;
+						}
+					}
+				}
+			}
+			output += input[i];
+			i++;
+			break;
+		case State.FENCED_CODE:
+			if (isAtLineStart(input, i) && matchFenceClosing(input, i, fenceChar, fenceLength)) {
+				let endLine = i;
+				while (endLine < input.length && input[endLine] !== "\n") endLine++;
+				if (endLine < input.length) endLine++;
+				output += input.slice(i, endLine);
+				i = endLine;
+				state = State.NORMAL;
+				fenceChar = "";
+				fenceLength = 0;
+				continue;
+			}
+			output += input[i];
+			i++;
+			break;
+	}
+	return output;
+}
+/**
+* Detect which syntax style is used in a document.
+*
+* Detection is based on the FORM TAG only:
+* - `<!-- form ... id="..." -->` → 'comments' style
+* - `{% form ... id="..." %}` → 'tags' style
+*
+* The form tag must have `id=` attribute to be recognized as a valid Markform document.
+* Other patterns (field, group, #id, .class) do not trigger detection by themselves.
+*
+* Code blocks (fenced and inline) are skipped to avoid false positives from examples.
+*
+* @param input - The markdown content
+* @returns The detected syntax style, defaults to 'tags' if no valid form tag found
+*/
+function detectSyntaxStyle(input) {
+	let state = State.NORMAL;
+	let fenceChar = "";
+	let fenceLength = 0;
+	let i = 0;
+	while (i < input.length) switch (state) {
+		case State.NORMAL:
+			if (isAtLineStart(input, i)) {
+				const fence = matchFenceOpening(input, i);
+				if (fence) {
+					state = State.FENCED_CODE;
+					fenceChar = fence.char;
+					fenceLength = fence.length;
+					i += fence.fullMatch.length;
+					continue;
+				}
+			}
+			if (input[i] === "`") {
+				let backtickCount = 0;
+				let j = i;
+				while (j < input.length && input[j] === "`") {
+					backtickCount++;
+					j++;
+				}
+				if (!(backtickCount >= 3 && isInLeadingWhitespace(input, i))) {
+					const end = findInlineCodeEnd(input, i);
+					if (end !== -1) {
+						i = end;
+						continue;
+					}
+				}
+			}
+			if (input.slice(i, i + 4) === "<!--") {
+				const endComment = input.indexOf("-->", i + 4);
+				if (endComment !== -1) {
+					if (isValidFormTag(input.slice(i + 4, endComment).trim())) return "comments";
+				}
+			}
+			if (input.slice(i, i + 2) === "{%") {
+				const endTag = input.indexOf("%}", i + 2);
+				if (endTag !== -1) {
+					if (isValidFormTag(input.slice(i + 2, endTag).trim())) return "tags";
+				}
+			}
+			i++;
+			break;
+		case State.FENCED_CODE:
+			if (isAtLineStart(input, i) && matchFenceClosing(input, i, fenceChar, fenceLength)) {
+				let endLine = i;
+				while (endLine < input.length && input[endLine] !== "\n") endLine++;
+				if (endLine < input.length) endLine++;
+				i = endLine;
+				state = State.NORMAL;
+				fenceChar = "";
+				fenceLength = 0;
+				continue;
+			}
+			i++;
+			break;
+	}
+	return "tags";
+}
+/**
+* Validate that a document uses only the specified syntax style.
+*
+* Scans the document for patterns of the "wrong" syntax and returns violations.
+* Only checks within form tag boundaries (comments outside form are ignored).
+* Code blocks (fenced and inline) are skipped.
+*
+* @param input - The markdown content
+* @param expectedSyntax - The syntax style that should be used
+* @returns Array of violations (empty if document is consistent)
+*/
+function validateSyntaxConsistency(input, expectedSyntax) {
+	const violations = [];
+	let state = State.NORMAL;
+	let fenceChar = "";
+	let fenceLength = 0;
+	let i = 0;
+	let lineNumber = 1;
+	let insideForm = false;
+	while (i < input.length) {
+		if (input[i] === "\n") lineNumber++;
+		switch (state) {
+			case State.NORMAL:
+				if (isAtLineStart(input, i)) {
+					const fence = matchFenceOpening(input, i);
+					if (fence) {
+						state = State.FENCED_CODE;
+						fenceChar = fence.char;
+						fenceLength = fence.length;
+						for (const ch of fence.fullMatch) if (ch === "\n") lineNumber++;
+						i += fence.fullMatch.length;
+						continue;
+					}
+				}
+				if (input[i] === "`") {
+					let backtickCount = 0;
+					let k = i;
+					while (k < input.length && input[k] === "`") {
+						backtickCount++;
+						k++;
+					}
+					if (!(backtickCount >= 3 && isInLeadingWhitespace(input, i))) {
+						const end = findInlineCodeEnd(input, i);
+						if (end !== -1) {
+							for (let m = i; m < end; m++) if (input[m] === "\n") lineNumber++;
+							i = end;
+							continue;
+						}
+					}
+				}
+				if (input.slice(i, i + 4) === "<!--") {
+					const endComment = input.indexOf("-->", i + 4);
+					if (endComment !== -1) {
+						const interior = input.slice(i + 4, endComment).trim();
+						if (isValidFormTag(interior)) insideForm = true;
+						else if (interior === "/form" || interior.startsWith("/form ")) insideForm = false;
+					}
+				}
+				if (input.slice(i, i + 2) === "{%") {
+					const endTag = input.indexOf("%}", i + 2);
+					if (endTag !== -1) {
+						const interior = input.slice(i + 2, endTag).trim();
+						if (isValidFormTag(interior)) insideForm = true;
+						else if (interior === "/form" || interior.startsWith("/form ")) insideForm = false;
+					}
+				}
+				if (insideForm) {
+					if (expectedSyntax === "comments") {
+						if (input.slice(i, i + 2) === "{%") {
+							const endTag = input.indexOf("%}", i + 2);
+							if (endTag !== -1) {
+								const pattern = input.slice(i, endTag + 2);
+								violations.push({
+									line: lineNumber,
+									pattern,
+									foundSyntax: "tags"
+								});
+							}
+						}
+					} else if (input.slice(i, i + 4) === "<!--") {
+						const endComment = input.indexOf("-->", i + 4);
+						if (endComment !== -1) {
+							const interior = input.slice(i + 4, endComment).trim();
+							const pattern = input.slice(i, endComment + 3);
+							if (startsWithMarkformTag(interior) || isValidFormTag(interior)) violations.push({
+								line: lineNumber,
+								pattern,
+								foundSyntax: "comments"
+							});
+							else if (interior.startsWith("/") && startsWithMarkformTag(interior.slice(1))) violations.push({
+								line: lineNumber,
+								pattern,
+								foundSyntax: "comments"
+							});
+							else if (/^[#.][a-zA-Z_-]/.test(interior)) violations.push({
+								line: lineNumber,
+								pattern,
+								foundSyntax: "comments"
+							});
+						}
+					}
+				}
+				i++;
+				break;
+			case State.FENCED_CODE:
+				if (isAtLineStart(input, i) && matchFenceClosing(input, i, fenceChar, fenceLength)) {
+					let endLine = i;
+					while (endLine < input.length && input[endLine] !== "\n") endLine++;
+					if (endLine < input.length) {
+						endLine++;
+						lineNumber++;
+					}
+					i = endLine;
+					state = State.NORMAL;
+					fenceChar = "";
+					fenceLength = 0;
+					continue;
+				}
+				i++;
+				break;
+		}
+	}
+	return violations;
+}
+
 //#endregion
 //#region src/utils/keySort.ts
 /**
@@ -496,6 +947,47 @@ function priorityKeyComparator(priorityKeys) {
 	});
 }
 
+//#endregion
+//#region src/utils/urlFormat.ts
+/**
+* Create a friendly abbreviated display name for a URL.
+* - Drops "www." prefix from domain
+* - Adds first portion of path (up to maxPathChars) if present
+* - Adds ellipsis (…) if path is truncated
+*
+* @param url - The URL to abbreviate
+* @param maxPathChars - Maximum characters to include from the path (default: 12)
+* @returns Friendly abbreviated URL (e.g., "example.com/docs/api…")
+*/
+function friendlyUrlAbbrev(url, maxPathChars = 12) {
+	try {
+		const parsed = new URL(url);
+		let hostname = parsed.hostname;
+		if (hostname.startsWith("www.")) hostname = hostname.slice(4);
+		const path = parsed.pathname.slice(1);
+		if (!path) return hostname;
+		if (path.length <= maxPathChars) return `${hostname}/${path}`;
+		return `${hostname}/${path.slice(0, maxPathChars)}…`;
+	} catch {
+		let result = url;
+		result = result.replace(/^https?:\/\//, "");
+		result = result.replace(/^www\./, "");
+		const maxLen = 30;
+		if (result.length > maxLen) return result.slice(0, maxLen) + "…";
+		return result;
+	}
+}
+/**
+* Format a URL as a markdown link with a friendly abbreviated display text.
+* The full URL is preserved as the link target.
+*
+* @param url - The URL to format
+* @returns Markdown link in format [friendly-abbrev](url)
+*/
+function formatUrlAsMarkdownLink(url) {
+	return `[${friendlyUrlAbbrev(url)}](${url})`;
+}
+
 //#endregion
 //#region src/engine/serialize.ts
 /**
@@ -545,6 +1037,137 @@ function pickFence(value) {
 	};
 }
 /**
+* Transform Markdoc syntax to HTML comment syntax.
+*
+* Patterns transformed:
+* - `{% tagname ... %}` → `<!-- tagname ... -->`
+* - `{% /tagname %}` → `<!-- /tagname -->`
+* - `{% tagname ... /%}` → `<!-- tagname ... /-->`
+* - `{% #id %}` → `<!-- #id -->`
+* - `{% .class %}` → `<!-- .class -->`
+*
+* Code blocks (fenced) are preserved unchanged.
+*
+* @param input - The Markdoc content
+* @returns The content with HTML comment syntax
+*/
+function postprocessToCommentSyntax(input) {
+	let output = "";
+	let inFencedCode = false;
+	let fenceChar = "";
+	let fenceLength = 0;
+	let i = 0;
+	while (i < input.length) {
+		if (!inFencedCode && (i === 0 || input[i - 1] === "\n")) {
+			let indent = 0;
+			let j = i;
+			while (j < input.length && input[j] === " " && indent < 4) {
+				indent++;
+				j++;
+			}
+			if (indent < 4 && (input[j] === "`" || input[j] === "~")) {
+				const fc = input[j];
+				let len = 0;
+				while (j + len < input.length && input[j + len] === fc) len++;
+				if (len >= 3) {
+					inFencedCode = true;
+					fenceChar = fc;
+					fenceLength = len;
+					let endLine = j + len;
+					while (endLine < input.length && input[endLine] !== "\n") endLine++;
+					if (endLine < input.length) endLine++;
+					output += input.slice(i, endLine);
+					i = endLine;
+					continue;
+				}
+			}
+		}
+		if (inFencedCode && (i === 0 || input[i - 1] === "\n")) {
+			let indent = 0;
+			let j = i;
+			while (j < input.length && input[j] === " " && indent < 4) {
+				indent++;
+				j++;
+			}
+			if (input[j] === fenceChar) {
+				let len = 0;
+				while (j + len < input.length && input[j + len] === fenceChar) len++;
+				if (len >= fenceLength) {
+					let afterFence = j + len;
+					let isClosing = true;
+					while (afterFence < input.length && input[afterFence] !== "\n") {
+						if (input[afterFence] !== " " && input[afterFence] !== "	") {
+							isClosing = false;
+							break;
+						}
+						afterFence++;
+					}
+					if (isClosing) {
+						if (afterFence < input.length) afterFence++;
+						output += input.slice(i, afterFence);
+						i = afterFence;
+						inFencedCode = false;
+						fenceChar = "";
+						fenceLength = 0;
+						continue;
+					}
+				}
+			}
+		}
+		if (inFencedCode) {
+			output += input[i];
+			i++;
+			continue;
+		}
+		if (input[i] === "`") {
+			let backtickCount = 0;
+			let j = i;
+			while (j < input.length && input[j] === "`") {
+				backtickCount++;
+				j++;
+			}
+			if (!(backtickCount >= 3 && isInLeadingWhitespace(input, i))) {
+				const end = findInlineCodeEnd(input, i);
+				if (end !== -1) {
+					output += input.slice(i, end);
+					i = end;
+					continue;
+				}
+			}
+		}
+		if (input.slice(i, i + 2) === "{%") {
+			const endTag = input.indexOf("%}", i + 2);
+			if (endTag !== -1) {
+				const interior = input.slice(i + 2, endTag).trim();
+				if (interior.endsWith("/")) {
+					const tagContent = interior.slice(0, -1).trim();
+					if (tagContent.startsWith("#") || tagContent.startsWith(".")) output += "<!-- " + tagContent + " /-->";
+					else output += "<!-- " + tagContent + " /-->";
+					i = endTag + 2;
+					continue;
+				}
+				if (interior.startsWith("/")) {
+					const tagName = interior.slice(1).trim();
+					output += "<!-- /" + tagName + " -->";
+					i = endTag + 2;
+					continue;
+				}
+				if (interior.startsWith("#") || interior.startsWith(".")) {
+					output += "<!-- " + interior + " -->";
+					i = endTag + 2;
+					continue;
+				}
+				output += "<!-- " + interior + " -->";
+				i = endTag + 2;
+				continue;
+			}
+		}
+		output += input[i];
+		i++;
+	}
+	return output;
+}
+/**
 * Format a value fence block with the given content.
 * Uses smart fence selection to avoid collision with code blocks in content.
 */
@@ -899,12 +1522,14 @@ function serializeYearField(field, response) {
 }
 /**
 * Serialize a cell value for table output.
+* URL-typed columns are formatted as markdown links with domain as display text.
 */
-function serializeCellValue(cell, _columnType) {
+function serializeCellValue(cell, columnType) {
 	if (cell.state === "skipped") return cell.reason ? `%SKIP:${cell.reason}%` : "%SKIP%";
 	if (cell.state === "aborted") return cell.reason ? `%ABORT:${cell.reason}%` : "%ABORT%";
 	if (cell.value === void 0 || cell.value === null) return "";
 	if (typeof cell.value === "number") return String(cell.value);
+	if (columnType === "url") return formatUrlAsMarkdownLink(cell.value);
 	return cell.value;
 }
 /**
@@ -1129,7 +1754,9 @@ function buildFrontmatter(metadata, specVersion) {
 */
 function serializeForm(form, opts) {
 	const specVersion = opts?.specVersion ?? MF_SPEC_VERSION;
-	return `${buildFrontmatter(form.metadata, specVersion)}\n\n${serializeFormSchema(form.schema, form.responsesByFieldId, form.docs, form.notes)}\n`;
+	let result = `${buildFrontmatter(form.metadata, specVersion)}\n\n${serializeFormSchema(form.schema, form.responsesByFieldId, form.docs, form.notes)}\n`;
+	if ((opts?.syntaxStyle ?? form.syntaxStyle ?? "tags") === "comments") result = postprocessToCommentSyntax(result);
+	return result;
 }
 /** Map checkbox state to GFM marker for raw markdown output */
 const STATE_TO_GFM_MARKER = {
@@ -1149,6 +1776,7 @@ function serializeFieldRaw(field, responses) {
 	const response = responses[field.id];
 	const lines = [];
 	lines.push(`**${field.label}:**`);
+	lines.push("");
 	const value = response?.state === "answered" ? response.value : void 0;
 	switch (field.kind) {
 		case "string": {
@@ -1179,9 +1807,10 @@ function serializeFieldRaw(field, responses) {
 		case "multi_select": {
 			const multiValue = value;
 			const selectedSet = new Set(multiValue?.selected ?? []);
-			const selectedOpts = field.options.filter((opt) => selectedSet.has(opt.id));
-			if (selectedOpts.length > 0) for (const opt of selectedOpts) lines.push(`- ${opt.label}`);
-			else lines.push("_(none selected)_");
+			for (const opt of field.options) {
+				const marker = selectedSet.has(opt.id) ? "x" : " ";
+				lines.push(`- [${marker}] ${opt.label}`);
+			}
 			break;
 		}
 		case "checkboxes": {
@@ -1194,13 +1823,13 @@ function serializeFieldRaw(field, responses) {
 		}
 		case "url": {
 			const urlValue = value;
-			if (urlValue?.value) lines.push(urlValue.value);
+			if (urlValue?.value) lines.push(formatUrlAsMarkdownLink(urlValue.value));
 			else lines.push("_(empty)_");
 			break;
 		}
 		case "url_list": {
 			const urlListValue = value;
-			if (urlListValue?.items && urlListValue.items.length > 0) for (const item of urlListValue.items) lines.push(`- ${item}`);
+			if (urlListValue?.items && urlListValue.items.length > 0) for (const item of urlListValue.items) lines.push(`- ${formatUrlAsMarkdownLink(item)}`);
 			else lines.push("_(empty)_");
 			break;
 		}
@@ -3078,4 +3707,5 @@ function applyPatches(form, patches) {
 }
 
 //#endregion
-export { isParseError as $, deriveExportPath as A, parseModelIdForDisplay as B, DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN as C, MAX_FORMS_IN_MENU as D, DEFAULT_ROLE_INSTRUCTIONS as E, SUGGESTED_LLMS as F, MarkformParseError as G, MarkformConfigError as H, WEB_SEARCH_CONFIG as I, ParseError as J, MarkformPatchError as K, formatSuggestedLlms as L, deriveSchemaPath as M, detectFileType as N, REPORT_EXTENSION as O, parseRolesFlag as P, isMarkformError as Q, getWebSearchConfig as R, DEFAULT_PRIORITY as S, DEFAULT_ROLES as T, MarkformError as U, MarkformAbortError as V, MarkformLlmError as W, isConfigError as X, isAbortError as Y, isLlmError as Z, DEFAULT_MAX_ISSUES_PER_TURN as _, validate as a, DEFAULT_MAX_TURNS as b, computeProgressSummary as c, serializeForm as d, isPatchError as et, serializeRawMarkdown as f, DEFAULT_FORMS_DIR as g, ALL_EXTENSIONS as h, inspect as i, deriveReportPath as j, USER_ROLE as k, computeStructureSummary as l, AGENT_ROLE as m, getAllFields as n, isValidationError as nt, computeAllSummaries as o, serializeReport as p, MarkformValidationError as q, getFieldsForRoles as r, computeFormState as s, applyPatches as t, isRetryableError as tt, isFormComplete as u, DEFAULT_MAX_PATCHES_PER_TURN as v, DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN as w, DEFAULT_PORT as x, DEFAULT_MAX_STEPS_PER_TURN as y, hasWebSearchSupport as z };
+export { isConfigError as $, MAX_FORMS_IN_MENU as A, formatSuggestedLlms as B, DEFAULT_MAX_TURNS as C, DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN as D, DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN as E, deriveSchemaPath as F, MarkformConfigError as G, hasWebSearchSupport as H, detectFileType as I, MarkformParseError as J, MarkformError as K, parseRolesFlag as L, USER_ROLE as M, deriveExportPath as N, DEFAULT_ROLES as O, deriveReportPath as P, isAbortError as Q, SUGGESTED_LLMS as R, DEFAULT_MAX_STEPS_PER_TURN as S, DEFAULT_PRIORITY as T, parseModelIdForDisplay as U, getWebSearchConfig as V, MarkformAbortError as W, MarkformValidationError as X, MarkformPatchError as Y, ParseError as Z, validateSyntaxConsistency as _, validate as a, isValidationError as at, DEFAULT_MAX_ISSUES_PER_TURN as b, computeProgressSummary as c, serializeForm as d, isLlmError as et, serializeRawMarkdown as f, preprocessCommentSyntax as g, detectSyntaxStyle as h, inspect as i, isRetryableError as it, REPORT_EXTENSION as j, DEFAULT_ROLE_INSTRUCTIONS as k, computeStructureSummary as l, friendlyUrlAbbrev as m, getAllFields as n, isParseError as nt, computeAllSummaries as o, serializeReport as p, MarkformLlmError as q, getFieldsForRoles as r, isPatchError as rt, computeFormState as s, applyPatches as t, isMarkformError as tt, isFormComplete as u, AGENT_ROLE as v, DEFAULT_PORT as w, DEFAULT_MAX_PATCHES_PER_TURN as x, DEFAULT_FORMS_DIR as y, WEB_SEARCH_CONFIG as z };
+//# sourceMappingURL=apply-CXsI5N9x.mjs.map