slackmark 0.6.0 → 0.6.2

package/dist/index.js

@@ -958,7 +958,7 @@ var DeterministicPlainTextRenderer = class {
 			parts.push(src[i] ?? "");
 			i += 1;
 		}
-		const raw = parts.join("").replace(/!\[[^\]]{0,200}\]\([^)]{0,3000}\)/g, " ").replace(/\[([^\]]{0,200})\]\([^)]{0,3000}\)/g, "$1").replace(/[#>*_`~]/g, "").replace(/\s+/g, " ").trim();
+		const raw = slackEntitiesToPlain(parts.join("")).replace(/!\[[^\]]{0,200}\]\([^)]{0,3000}\)/g, " ").replace(/\[([^\]]{0,200})\]\([^)]{0,3000}\)/g, "$1").replace(/^[ \t]*#{1,6}[ \t]*/gm, "").replace(/^[ \t]*>[ \t]?/gm, "").replace(/[*_`~]/g, "").replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1").replace(/\s+/g, " ").trim();
 		return raw.length > 0 ? raw : " ";
 	}
 	renderFromBlocks(blocks) {
@@ -1003,7 +1003,37 @@ var DeterministicPlainTextRenderer = class {
 	}
 };
 function stripMrkdwn(text) {
-	return text.replace(/<([^|>]{1,3000})\|([^>]{0,500})>/g, "$2").replace(/<([^>]{1,3000})>/g, "$1").replace(/[*_~`]/g, "");
+	return slackEntitiesToPlain(text).replace(/[*_~`]/g, "");
+}
+/**
+* Slack entity syntax rendered the way {@link inlinesToPlain} renders the
+* equivalent structured element, so a mention reads the same whether it reached
+* the output as a `rich_text` element or as literal text in a `markdown` block.
+*
+* This has to run before markdown punctuation is stripped. `>` closes every one
+* of these forms and also marks a blockquote, and `#` opens a channel reference
+* and also a heading, so stripping those characters first leaves `<@U123` behind.
+*/
+function slackEntitiesToPlain(text) {
+	return text.replace(/<([^<>]{1,3000})>/g, (_match, body) => {
+		const [target, label] = splitOnce(body, "|");
+		if (target.startsWith("@")) return `@${target.slice(1)}`;
+		if (target.startsWith("#")) return `#${target.slice(1)}`;
+		if (target.startsWith("!")) return specialToPlain(target.slice(1), label);
+		return label ?? target;
+	});
+}
+/** `<!here>`, `<!subteam^S1|@x>`, `<!date^…|fallback>` and friends. */
+function specialToPlain(command, label) {
+	const [name, argument] = splitOnce(command, "^");
+	if (name === "subteam") return `@${argument ?? ""}`;
+	if (name === "date") return label ?? command;
+	return `@${name}`;
+}
+function splitOnce(value, separator) {
+	const index = value.indexOf(separator);
+	if (index === -1) return [value, void 0];
+	return [value.slice(0, index), value.slice(index + separator.length)];
 }
 function richTextToPlain(elements) {
 	const parts = [];
@@ -1370,6 +1400,38 @@ function parseNumberList(inner) {
 	return inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => Number(s));
 }
 //#endregion
+//#region src/adapters/block-to-plain-text.ts
+/**
+* Plain text for a block that had to be flattened into a single text run.
+*
+* `mdast-util-to-string` concatenates every descendant with no separator, so a
+* table collapses to "ab12" and sibling paragraphs run together as
+* "para onepara two". Flattening is already flagged as a degradation; the text
+* it leaves behind still has to be readable, so re-insert the separators the
+* structure carried.
+*/
+function blockToPlainText(node) {
+	if (node.type === "table") return node.children.map((row) => row.children.map((cell) => toString(cell)).join(" | ")).join("\n");
+	if (node.type === "list") return node.children.map((item) => `• ${blockToPlainText(item)}`).join("\n");
+	if (node.type === "blockquote" || node.type === "listItem" || node.type === "footnoteDefinition") return node.children.map((child) => blockToPlainText(child)).join("\n");
+	return toString(node);
+}
+/**
+* Link and image URLs carried by a block that is about to be flattened.
+* {@link blockToPlainText} keeps only labels and alt text, so callers must
+* flag these before they disappear — silent omission is a bug even when the
+* surrounding flattening is itself already flagged.
+*/
+function collectFlattenedUrls(node, into) {
+	if (node === null || typeof node !== "object") return;
+	const record = node;
+	if ((record.type === "link" || record.type === "image") && typeof record.url === "string") into.push({
+		nodeType: record.type,
+		url: record.url
+	});
+	if (record.children !== void 0) for (const child of record.children) collectFlattenedUrls(child, into);
+}
+//#endregion
 //#region src/budget/operation-scope.ts
 function createOperationScope(options, stage) {
 	validateOperationOptions(options);
@@ -1734,6 +1796,7 @@ var SlackMarkConverter = class {
 	* operation context. The returned promise tracks underlying conversion work.
 	*/
 	async convertWithContext(markdown, options, operation, receipts = new RecordingReceiptCollector()) {
+		resolveConfig(this.defaultOptions, options, operation);
 		const multi = await this.convertToMessagesWithContext(markdown, {
 			...options,
 			overflow: OverflowMode.Degrade
@@ -1820,6 +1883,17 @@ var SlackMarkConverter = class {
 			footnoteOrder.forEach((id, i) => footnoteNumbers.set(id, i + 1));
 			const footnoteBlocks = buildFootnoteBlocks(footnoteOrder.map((id, i) => {
 				const def = footnotes.get(id);
+				if (def !== void 0) {
+					const dropped = [];
+					collectFlattenedUrls(def, dropped);
+					for (const { nodeType, url } of dropped) degradations.add({
+						nodeType,
+						from: url,
+						to: "label_only",
+						reason: "Footnote body renders as plain context text; URL dropped",
+						path: `footnote[${String(i + 1)}]`
+					});
+				}
 				return {
 					n: i + 1,
 					text: def !== void 0 ? footnoteBodyText(def, footnoteNumbers).trim() : id
@@ -2026,6 +2100,19 @@ function collectRefs(tree, degradations) {
 	};
 }
 /**
+* Separator inserted between the children of a flattened footnote body node.
+* Without these, sibling paragraphs and table cells run together as
+* "para onepara two" / "ab12".
+*/
+const FOOTNOTE_CHILD_SEPARATORS = /* @__PURE__ */ new Map([
+	["footnoteDefinition", "\n"],
+	["blockquote", "\n"],
+	["list", "\n"],
+	["listItem", "\n"],
+	["table", "\n"],
+	["tableRow", " | "]
+]);
+/**
 * Footnote definition body as plain text with nested footnote references
 * rendered as their `[n]` markers (mdast-util-to-string drops them entirely).
 */
@@ -2041,7 +2128,8 @@ function footnoteBodyText(node, numbers) {
 	if (record.children !== void 0) {
 		const parts = [];
 		for (const child of record.children) parts.push(footnoteBodyText(child, numbers));
-		return parts.join("");
+		const separator = record.type !== void 0 ? FOOTNOTE_CHILD_SEPARATORS.get(record.type) ?? "" : "";
+		return parts.join(separator);
 	}
 	return "";
 }
@@ -2353,6 +2441,43 @@ function countHoistableImages(nodes, ctx) {
 	}
 	return count;
 }
+/**
+* Record images a link label swallows. Slack link elements carry plain text, and hoisting
+* would detach the image from its link, so only the alt text survives.
+*/
+function flagImagesLostInLabel(nodes, ctx) {
+	for (const node of nodes) switch (node.type) {
+		case "image":
+			addImageLostInLabel(node.url, ctx);
+			break;
+		case "imageReference":
+			addImageLostInLabel(ctx.definitions.get(node.identifier.toLowerCase())?.url ?? node.identifier, ctx);
+			break;
+		case "strong":
+		case "emphasis":
+		case "delete":
+			flagImagesLostInLabel(node.children, ctx);
+			break;
+		case "text":
+		case "inlineCode":
+		case "break":
+		case "link":
+		case "linkReference":
+		case "footnoteReference":
+		case "html":
+		case "inlineMath": break;
+		default: break;
+	}
+}
+function addImageLostInLabel(url, ctx) {
+	ctx.degradations.add({
+		nodeType: "image",
+		from: "image",
+		to: "text",
+		reason: `Image nested in a link is dropped; only its alt text survives (${url})`,
+		path: ctx.path
+	});
+}
 function truncateLabel(label, max) {
 	if (label.length <= max) return {
 		text: label,
@@ -2639,6 +2764,7 @@ function reassembleSlackLabeledLink(work, i, style) {
 function emitLink(node, ctx, style) {
 	const url = node.url;
 	const text = phrasingToPlain(node.children);
+	flagImagesLostInLabel(node.children, ctx);
 	const pipeIndex = url.indexOf("|");
 	if (pipeIndex > 0 && HTTP_URL_RE.test(url) && text === url) {
 		const realUrl = url.slice(0, pipeIndex);
@@ -2673,11 +2799,14 @@ function emitLink(node, ctx, style) {
 }
 function emitLinkReference(node, ctx, style) {
 	const def = ctx.definitions.get(node.identifier.toLowerCase());
-	if (def === void 0) return [{
-		type: "text",
-		text: phrasingToPlain(node.children) || node.identifier,
-		style: styleOrUndefined(style)
-	}];
+	if (def === void 0) {
+		flagImagesLostInLabel(node.children, ctx);
+		return [{
+			type: "text",
+			text: phrasingToPlain(node.children) || node.identifier,
+			style: styleOrUndefined(style)
+		}];
+	}
 	return emitLink({
 		type: "link",
 		url: def.url,
@@ -2914,13 +3043,14 @@ function flattenQuote(quote, ctx) {
 			reason: "Nested list inside blockquote flattened",
 			path: ctx.path
 		});
+		flagFlattenedUrls(child, ctx);
 		if (parts.length > 0) parts.push({
 			type: "text",
 			text: "\n"
 		});
 		for (const item of child.children) parts.push({
 			type: "text",
-			text: `• ${toString(item)}\n`
+			text: `• ${blockToPlainText(item)}\n`
 		});
 	} else if (child.type === "code") {
 		ctx.degradations.add({
@@ -2947,13 +3077,14 @@ function flattenQuote(quote, ctx) {
 			reason: "Nested block inside blockquote flattened",
 			path: ctx.path
 		});
+		flagFlattenedUrls(child, ctx);
 		if (parts.length > 0) parts.push({
 			type: "text",
 			text: "\n"
 		});
 		parts.push({
 			type: "text",
-			text: toString(child)
+			text: blockToPlainText(child)
 		});
 	}
 	return parts.length > 0 ? parts : [{
@@ -2961,6 +3092,18 @@ function flattenQuote(quote, ctx) {
 		text: " "
 	}];
 }
+/** Flattening keeps labels and alt text only; every dropped URL gets a record. */
+function flagFlattenedUrls(node, ctx) {
+	const dropped = [];
+	collectFlattenedUrls(node, dropped);
+	for (const { nodeType, url } of dropped) ctx.degradations.add({
+		nodeType,
+		from: url,
+		to: "label_only",
+		reason: "Block flattened into quote text; URL dropped",
+		path: ctx.path
+	});
+}
 //#endregion
 //#region src/slack/slack-upload-error.ts
 /** See the brand rationale in `errors.ts`: this class is bundled into more than one entry. */
@@ -3863,11 +4006,26 @@ function emitListItem(item, ctx) {
 			reason: "Block child of list item flattened into text",
 			path: ctx.path
 		});
-		const text = toString(child);
-		if (text.length > 0) phrasing.push({
-			type: "text",
-			value: text
+		const dropped = [];
+		collectFlattenedUrls(child, dropped);
+		for (const { nodeType, url } of dropped) ctx.degradations.add({
+			nodeType,
+			from: url,
+			to: "label_only",
+			reason: "Block flattened into list item text; URL dropped",
+			path: ctx.path
 		});
+		const text = blockToPlainText(child);
+		if (text.length > 0) {
+			if (sawBlock) phrasing.push({
+				type: "text",
+				value: "\n"
+			});
+			phrasing.push({
+				type: "text",
+				value: text
+			});
+		}
 		sawBlock = true;
 	}
 	const inline = emitPhrasing(phrasing, ctx);
@@ -4438,10 +4596,30 @@ function markdownThenAscii(table, cellChars, reason) {
 function buildTableBlock(table, ctx) {
 	return {
 		type: "table",
-		rows: table.children.map((row, rowIndex) => row.children.map((cell) => cellToSlack(cell, ctx, rowIndex === 0))),
+		rows: buildRows(table, ctx, "table"),
 		column_settings: columnSettings(table)
 	};
 }
+/**
+* Emit every cell and flag the blanks that had to be padded to satisfy Slack's
+* `minLength: 1` on `raw_text`/`raw_number` text.
+*/
+function buildRows(table, ctx, mode) {
+	let padded = 0;
+	const rows = table.children.map((row, rowIndex) => row.children.map((cell) => {
+		const emitted = mode === "data_table" ? cellForDataTable(cell, ctx, rowIndex) : cellToSlack(cell, ctx, rowIndex === 0);
+		if (emitted.type === "raw_text" && emitted.text === EMPTY_CELL_TEXT) padded += 1;
+		return emitted;
+	}));
+	if (padded > 0) ctx.degradations.add({
+		nodeType: "table",
+		from: `${String(padded)} empty cells`,
+		to: "single-space cells",
+		reason: "Slack rejects empty table cell text; padded to one space",
+		path: ctx.path
+	});
+	return rows;
+}
 function buildDataTable(table, ctx) {
 	const captionRaw = ctx.precedingHeading !== void 0 && ctx.precedingHeading.length > 0 ? ctx.precedingHeading : "Table";
 	const caption = sliceSurrogateSafe(captionRaw, 150);
@@ -4455,16 +4633,25 @@ function buildDataTable(table, ctx) {
 	return {
 		type: "data_table",
 		caption,
-		rows: table.children.map((row, rowIndex) => row.children.map((cell) => cellForDataTable(cell, ctx, rowIndex))),
+		rows: buildRows(table, ctx, "data_table"),
 		page_size: 5,
 		row_header_column_index: 0
 	};
 }
+/**
+* Slack requires at least one character in every `raw_text`/`raw_number` cell
+* (`minLength: 1`), so a blank markdown cell renders as a single space.
+* https://docs.slack.dev/reference/block-kit/blocks/data-table-block
+*/
+const EMPTY_CELL_TEXT = " ";
+function cellText(text) {
+	return text.length >= 1 ? text : EMPTY_CELL_TEXT;
+}
 /** Slack forbids rich_text in data_table headers; keep emission and budget counting aligned. */
 function cellForDataTable(cell, ctx, rowIndex) {
 	if (rowIndex === 0) return {
 		type: "raw_text",
-		text: toString(cell)
+		text: cellText(toString(cell))
 	};
 	return cellToSlack(cell, ctx, false);
 }
@@ -4483,7 +4670,7 @@ function cellToSlack(cell, ctx, header) {
 		};
 		return {
 			type: "raw_text",
-			text: plainText
+			text: cellText(plainText)
 		};
 	}
 	return {
@@ -4554,66 +4741,266 @@ function asciiTableBlock(table) {
 	return preformattedRichText(toPipeMarkdown(table), void 0);
 }
 //#endregion
+//#region src/adapters/phrasing-to-markdown.ts
+/**
+* Inline markdown for content bound for a Slack `markdown` block.
+*
+* Slack renders standard markdown in that block — links, bold, italic,
+* strikethrough, inline code, and images (as link text) — so flattening inlines
+* to bare text discards fidelity the destination would have carried.
+*
+* Text nodes pass through unescaped, exactly as they did when this content was
+* flattened wholesale. This only re-adds syntax around nodes that already
+* carried that meaning in the source, so a document with no links converts
+* byte-identically to before.
+*/
+function phrasingToMarkdown(nodes, definitions) {
+	let out = "";
+	for (const node of nodes) out += nodeToMarkdown(node, definitions);
+	return out;
+}
+function nodeToMarkdown(node, definitions) {
+	if (node.type === "text") return node.value;
+	if (node.type === "inlineCode") return `\`${node.value}\``;
+	if (node.type === "strong") return `**${phrasingToMarkdown(node.children, definitions)}**`;
+	if (node.type === "emphasis") return `_${phrasingToMarkdown(node.children, definitions)}_`;
+	if (node.type === "delete") return `~~${phrasingToMarkdown(node.children, definitions)}~~`;
+	if (node.type === "link") return labelledLink(phrasingToMarkdown(node.children, definitions), node.url);
+	if (node.type === "image") return `![${node.alt ?? ""}](${node.url})`;
+	if (node.type === "linkReference") {
+		const url = definitions.get(node.identifier)?.url;
+		const label = phrasingToMarkdown(node.children, definitions);
+		return url === void 0 ? label : labelledLink(label, url);
+	}
+	if (node.type === "imageReference") {
+		const url = definitions.get(node.identifier)?.url;
+		const alt = node.alt ?? "";
+		return url === void 0 ? alt : `![${alt}](${url})`;
+	}
+	if (node.type === "break") return " ";
+	return toString(node);
+}
+/**
+* An autolink already reads as its own URL; wrapping it as `[url](url)` would be
+* noise, and bare URLs are what this path emitted before.
+*/
+function labelledLink(label, url) {
+	return label === url ? url : `[${label}](${url})`;
+}
+//#endregion
 //#region src/adapters/task-list-adapter.ts
 /**
 * Task lists → markdown block (checkboxes); fallback unicode in rich_text_list.
+*
+* Both rungs carry inline links: Slack renders `[label](url)` in a `markdown`
+* block, and a rich_text section holds real `link` elements next to the unicode
+* checkbox. Only a block child of an item (a table, a code fence) still has to
+* be flattened, and only that flattening drops URLs.
 */
 var TaskListAdapter = class {
 	match(node, _ctx) {
 		return node.type === "list" && isTaskList(node);
 	}
-	plan(node, _ctx) {
+	plan(node, ctx) {
 		const list = node;
-		const md = serializeTaskList(list);
-		return [{
+		const md = serializeTaskList(list, ctx.definitions);
+		const hoistCount = countHoistableImagesInTaskList(list, ctx);
+		const candidates = [{
 			requires: ["markdownBlock"],
 			budget: {
 				blocks: 1,
 				markdownChars: md.length
 			},
-			emit: () => {
+			emit: (emitCtx) => {
+				flagBlockChildUrlLoss(list, emitCtx);
+				flagImagesRenderedAsLinks(list, emitCtx);
 				return [{
 					type: "markdown",
 					text: md
 				}];
 			}
 		}, {
+			budget: { blocks: 1 + hoistCount },
+			emit: (emitCtx) => {
+				flagUnicodeCheckboxes(list, emitCtx);
+				return emitUnicodeTaskBlocks(list, emitCtx, HOIST_IMAGES);
+			}
+		}];
+		if (hoistCount > 0) candidates.push({
 			budget: { blocks: 1 },
-			emit: (ctx) => {
-				ctx.degradations.add({
+			emit: (emitCtx) => {
+				flagUnicodeCheckboxes(list, emitCtx);
+				emitCtx.degradations.add({
 					nodeType: "list",
-					from: "markdown.task_list",
-					to: "rich_text_list.unicode_checkbox",
-					reason: "markdownBlock unavailable or budget exhausted",
-					path: ctx.path
+					from: "rich_text+images",
+					to: "rich_text",
+					reason: "Budget exhausted for hoisted task list images; emitting text only",
+					path: emitCtx.path
 				});
-				return [unicodeTaskList(list, ctx)];
+				return emitUnicodeTaskBlocks(list, emitCtx, TEXT_ONLY);
 			}
-		}];
+		});
+		return candidates;
 	}
 };
-function serializeTaskList(list, indent = 0) {
+function flagUnicodeCheckboxes(list, ctx) {
+	flagBlockChildUrlLoss(list, ctx);
+	ctx.degradations.add({
+		nodeType: "list",
+		from: "markdown.task_list",
+		to: "rich_text_list.unicode_checkbox",
+		reason: "markdownBlock unavailable or budget exhausted",
+		path: ctx.path
+	});
+}
+/**
+* URLs inside a block child of an item. Both rungs flatten a table or code fence
+* to plain text, which keeps labels only, so this loss is real on either path.
+* Inline links in a paragraph are not flagged: both rungs now carry them.
+*/
+function flagBlockChildUrlLoss(list, ctx) {
+	for (const item of list.children) for (const child of item.children) {
+		if (child.type === "list") {
+			flagBlockChildUrlLoss(child, ctx);
+			continue;
+		}
+		if (child.type === "paragraph") continue;
+		const urls = [];
+		collectFlattenedUrls(child, urls);
+		for (const { nodeType, url } of urls) ctx.degradations.add({
+			nodeType,
+			from: url,
+			to: "label_only",
+			reason: "Block child of task list item flattened into text; URL dropped",
+			path: ctx.path
+		});
+	}
+}
+/**
+* Slack renders `![alt](url)` in a `markdown` block as link text, so on that rung
+* the URL survives but the image does not. A fidelity note, not a dropped URL.
+* The rich_text rung hoists images into real image blocks instead.
+*/
+function flagImagesRenderedAsLinks(list, ctx) {
+	for (const item of list.children) for (const child of item.children) {
+		if (child.type === "list") {
+			flagImagesRenderedAsLinks(child, ctx);
+			continue;
+		}
+		if (child.type !== "paragraph") continue;
+		const urls = [];
+		collectRenderedImageUrls(child, ctx.definitions, urls);
+		for (const url of urls) ctx.degradations.add({
+			nodeType: "image",
+			from: url,
+			to: "link",
+			reason: "Slack renders images in a markdown block as link text",
+			path: ctx.path
+		});
+	}
+}
+/**
+* Image URLs this rung will render as link text, reference images included.
+* {@link collectFlattenedUrls} cannot see those: a reference carries an identifier,
+* not a url. But {@link phrasingToMarkdown} resolves it and emits the same
+* `![alt](url)`, so it loses the same fidelity and owes the same note. An
+* unresolvable reference emits no image, and so is correctly skipped here.
+*/
+function collectRenderedImageUrls(node, definitions, into) {
+	if (node === null || typeof node !== "object") return;
+	const record = node;
+	if (record.type === "image" && typeof record.url === "string") into.push(record.url);
+	if (record.type === "imageReference" && typeof record.identifier === "string") {
+		const resolved = definitions.get(record.identifier)?.url;
+		if (resolved !== void 0) into.push(resolved);
+	}
+	for (const child of record.children ?? []) collectRenderedImageUrls(child, definitions, into);
+}
+function serializeTaskList(list, definitions, indent = 0) {
 	const pad = "  ".repeat(indent);
 	const lines = [];
 	for (const item of list.children) {
-		const box = item.checked === true ? "[x]" : "[ ]";
-		const text = itemText(item);
-		lines.push(`${pad}- ${box} ${text}`);
-		for (const child of item.children) if (child.type === "list") lines.push(serializeTaskList(child, indent + 1));
+		const text = itemMarkdown(item, definitions);
+		lines.push(`${pad}${taskMarker(item.checked)}${escapeLeadingCheckbox(item.checked, text)}`);
+		for (const child of item.children) if (child.type === "list") lines.push(serializeTaskList(child, definitions, indent + 1));
 	}
 	return lines.join("\n");
 }
-function itemText(item) {
+/**
+* `checked` has three states, and a plain bullet is not an unchecked task. A
+* mixed list holds both, so collapsing `undefined` into `false` renders work the
+* author never wrote as unfinished. The rich_text rung already omits the prefix
+* for these items; this keeps the two rungs saying the same thing.
+*/
+function taskMarker(checked) {
+	if (checked === true) return "- [x] ";
+	if (checked === false) return "- [ ] ";
+	return "- ";
+}
+/**
+* A plain item whose text happens to start with `[x]` would be re-parsed as a
+* checked task once the marker in front of it is a bare bullet, which is the same
+* meaning change {@link taskMarker} exists to avoid. `- [x] ` with a trailing
+* space is exactly this: GFM reads it as a plain item whose literal text is
+* `[x]`. Escaping the bracket keeps it literal.
+*/
+function escapeLeadingCheckbox(checked, text) {
+	if (checked !== void 0 && checked !== null) return text;
+	return /^\[[ xX]\]/.test(text) ? `\\${text}` : text;
+}
+/**
+* Item content as inline markdown. Slack renders links, emphasis and code in a
+* `markdown` block, so flattening those to bare text would discard fidelity the
+* destination carries natively.
+*/
+function itemMarkdown(item, definitions) {
 	const parts = [];
-	for (const child of item.children) if (child.type === "paragraph") parts.push(toString(child));
-	else if (child.type !== "list") parts.push(toString(child));
+	for (const child of item.children) if (child.type === "paragraph") parts.push(phrasingToMarkdown(child.children, definitions));
+	else if (child.type !== "list") parts.push(blockToPlainText(child));
 	return parts.join(" ").trim();
 }
-function unicodeTaskList(list, ctx) {
-	return {
+/** Phrasing content of a task item, for hoist counting and for emission. */
+function taskItemPhrasing(item) {
+	const phrasing = [];
+	for (const child of item.children) {
+		let segment = [];
+		if (child.type === "paragraph") segment = child.children;
+		else if (child.type !== "list") {
+			const text = blockToPlainText(child);
+			segment = text.length > 0 ? [{
+				type: "text",
+				value: text
+			}] : [];
+		}
+		if (segment.length === 0) continue;
+		if (phrasing.length > 0) phrasing.push({
+			type: "text",
+			value: " "
+		});
+		phrasing.push(...segment);
+	}
+	return phrasing;
+}
+function countHoistableImagesInTaskList(list, ctx) {
+	let count = 0;
+	for (const item of list.children) {
+		count += countHoistableImages(taskItemPhrasing(item), ctx);
+		for (const child of item.children) if (child.type === "list") count += countHoistableImagesInTaskList(child, ctx);
+	}
+	return count;
+}
+/** Named at the call site, because `emitUnicodeTaskBlocks(list, ctx, true)` says nothing. */
+const HOIST_IMAGES = true;
+const TEXT_ONLY = false;
+function emitUnicodeTaskBlocks(list, ctx, hoistImages) {
+	const { elements, hoistedImages } = emitUnicodeTaskTree(list, 0, ctx);
+	const blocks = [{
 		type: "rich_text",
-		elements: emitUnicodeTaskTree(list, 0, ctx)
-	};
+		elements
+	}];
+	if (!hoistImages) return blocks;
+	for (const image of hoistedImages) blocks.push(hoistedImageBlock(image, ctx));
+	return blocks;
 }
 function emitUnicodeTaskTree(list, indent, ctx) {
 	let effectiveIndent = indent;
@@ -4628,6 +5015,7 @@ function emitUnicodeTaskTree(list, indent, ctx) {
 		effectiveIndent = 6;
 	}
 	const out = [];
+	const hoistedImages = [];
 	let pendingSections = [];
 	const flush = () => {
 		if (pendingSections.length === 0) return;
@@ -4641,18 +5029,28 @@ function emitUnicodeTaskTree(list, indent, ctx) {
 	};
 	for (const item of list.children) {
 		const prefix = item.checked === true ? "☑ " : item.checked === false ? "☐ " : "";
+		const inline = emitPhrasing(taskItemPhrasing(item), ctx);
+		hoistedImages.push(...inline.hoistedImages);
+		const elements = prefix === "" ? [...inline.elements] : [{
+			type: "text",
+			text: prefix
+		}, ...inline.elements];
 		pendingSections.push({
 			type: "rich_text_section",
-			elements: [{
+			elements: elements.length > 0 ? elements : [{
 				type: "text",
-				text: `${prefix}${itemText(item)}`
+				text: " "
 			}]
 		});
 		const childLists = [];
 		for (const child of item.children) if (child.type === "list") childLists.push(child);
 		if (childLists.length === 0) continue;
 		flush();
-		for (const child of childLists) out.push(...emitUnicodeTaskTree(child, effectiveIndent + 1, ctx));
+		for (const child of childLists) {
+			const nested = emitUnicodeTaskTree(child, effectiveIndent + 1, ctx);
+			out.push(...nested.elements);
+			hoistedImages.push(...nested.hoistedImages);
+		}
 	}
 	flush();
 	if (out.length === 0) out.push({
@@ -4667,7 +5065,10 @@ function emitUnicodeTaskTree(list, indent, ctx) {
 		}],
 		indent: effectiveIndent
 	});
-	return out;
+	return {
+		elements: out,
+		hoistedImages
+	};
 }
 //#endregion
 //#region src/adapters/thematic-break-adapter.ts
@@ -5080,7 +5481,12 @@ function validateTableCells(rows, path, colsMessage, issues) {
 		});
 		for (const [c, cell] of row.entries()) {
 			chars += cellCharCount(cell);
-			if (cell.type === "rich_text") validateRichTextBlock(cell, `${path}.rows[${String(r)}][${String(c)}]`, issues);
+			const cellPath = `${path}.rows[${String(r)}][${String(c)}]`;
+			if (cell.type === "rich_text") validateRichTextBlock(cell, cellPath, issues);
+			else if (cell.text.length < 1) issues.push({
+				path: cellPath,
+				message: "table cell text is empty"
+			});
 		}
 	}
 	return chars;