lens-content-processor 0.79.0 → 0.80.0

package/dist/flattener/index.js

@@ -15,7 +15,8 @@ import { fileNameToSlug } from "../utils/slug.js";
 import { extractArticleExcerpt, resolveArticleSource, } from "../bundler/article.js";
 import { extractVideoExcerpt, resolveVideoRange, } from "../bundler/video.js";
 import { attachSourceLine, getSourceLine } from "../source-location.js";
-import { collectBlockTargets, collectBlockTargetsFrom, resolveSamePageLinks, } from "../same-page-links.js";
+import { collectBlockTargets, collectBlockTargetsFrom, lazyBlockTargets, resolveSamePageLinks, } from "../same-page-links.js";
+import { attachDroppedSegments, dropCause, droppedContent, droppedSection, droppedSegment, droppedSegmentsOf, fileStem, isBuilt, placeDropped, placedAfter, } from "../dropped.js";
 function countWords(text) {
     return text.trim().split(/\s+/).filter(Boolean).length;
 }
@@ -242,6 +243,8 @@ function mergeAiContext(moduleCtx, submoduleCtx) {
     }
     return out;
 }
+/** The error for sections before the first `# Submodule:`, which no page holds. */
+const OUTSIDE_SUBMODULES = "Content found outside submodule boundaries — all content must be inside a submodule";
 export function validateBoundaries(items, file) {
     const errors = [];
     const hasBoundaries = items.some(isBoundary);
@@ -255,7 +258,7 @@ export function validateBoundaries(items, file) {
     if (sectionsBefore.length > 0) {
         errors.push({
             file,
-            message: "Content found outside submodule boundaries — all content must be inside a submodule",
+            message: OUTSIDE_SUBMODULES,
             severity: "error",
         });
     }
@@ -333,39 +336,50 @@ export function splitAtBoundaries(items, parentSlug, parentTitle) {
     return groups;
 }
 /**
- * Flatten a single ParsedLens into output Segments.
- * This is the shared core used by all lens-processing functions.
+ * Flatten the parsed segments of a lens or of an outcome's test into output
+ * Segments: the shared core of every lens and test path.
  *
- * For each segment in the lens, calls convertSegment to resolve article/video content.
- * Then applies collapsed content for article segments from the same source.
+ * Article segments are resolved up front, grouped per source file (one parsed
+ * segment can expand to several output segments when the article declares
+ * inline videos); every other segment goes through convertSegment.
+ * `collapsed: false` (test sections) skips the collapsed text at excerpt
+ * boundaries. `dropped` starts with the segments the parser refused.
  */
-function flattenSingleLens(lens, lensPath, files, visitedPaths, tierMap) {
+function flattenSegments(parsed, path, files, visitedPaths, tierMap, options) {
+    const parsedSegments = parsed.segments;
     const errors = [];
     const segments = [];
-    const blockTargets = collectBlockTargetsFrom(lens.segments.flatMap((segment) => "content" in segment && typeof segment.content === "string"
+    const dropped = [...droppedSegmentsOf(parsed)];
+    const blockTargets = lazyBlockTargets(() => collectBlockTargetsFrom(parsedSegments.flatMap((segment) => "content" in segment && typeof segment.content === "string"
         ? [segment.content]
-        : []));
-    // Article segments are resolved up front, grouped per source file (one
-    // parsed segment can expand to several output segments when the article
-    // declares inline videos).
-    const articlePlan = planLensArticles(lens.segments, lensPath, files, visitedPaths, tierMap, { collapsed: true });
-    for (let i = 0; i < lens.segments.length; i++) {
-        const parsedSegment = lens.segments[i];
+        : [])));
+    const articlePlan = planLensArticles(parsedSegments, path, files, visitedPaths, tierMap, options);
+    for (let i = 0; i < parsedSegments.length; i++) {
+        const parsedSegment = parsedSegments[i];
         const planned = articlePlan.get(i);
         if (planned) {
             errors.push(...planned.errors);
+            dropped.push(...planned.dropped);
             for (const segment of planned.segments) {
                 segments.push(prependFrames(segment, parsedSegment.frames));
             }
             continue;
         }
-        const segmentResult = convertSegment(parsedSegment, lensPath, files, visitedPaths, tierMap, blockTargets);
+        const segmentResult = convertSegment(parsedSegment, path, files, visitedPaths, tierMap, blockTargets);
         errors.push(...segmentResult.errors);
         if (segmentResult.segment) {
             segments.push(prependFrames(segmentResult.segment, parsedSegment.frames));
         }
+        else {
+            dropped.push(...droppedSegment(parsedSegment.type, sourceOf(parsedSegment), path, segmentResult.errors));
+        }
     }
-    return { segments, errors };
+    return { segments, errors, dropped };
+}
+/** The `source::` wikilink of a parsed segment, when its type has one. */
+function sourceOf(segment) {
+    const source = segment.source;
+    return typeof source === "string" ? source : undefined;
 }
 // ─── Module flattening ───
 /**
@@ -384,11 +398,11 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
                     severity: "error",
                 },
             ],
+            dropped: [],
         };
     }
     visitedPaths.add(modulePath);
     const errors = [];
-    let moduleError;
     // Get module content
     const moduleContent = files.get(modulePath);
     if (!moduleContent) {
@@ -397,16 +411,27 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
             message: `Module file not found: ${modulePath}`,
             severity: "error",
         });
-        return { module: null, modules: [], errors };
+        return { module: null, modules: [], errors, dropped: [] };
     }
     // Parse the module
     const moduleResult = parseModule(moduleContent, modulePath);
     errors.push(...moduleResult.errors);
     if (!moduleResult.module) {
-        return { module: null, modules: [], errors };
+        return { module: null, modules: [], errors, dropped: [] };
     }
     const parsedModule = moduleResult.module;
     const flatItems = [];
+    // A header the parser refused (an unknown type, such as "# Lense:") left out
+    // the section it would have started: a placeholder stands where the header
+    // is, and keeps its place as a lens does (src/dropped.ts).
+    const refused = [...moduleResult.refused];
+    const placeRefused = (beforeLine = Infinity) => {
+        while (refused.length > 0 && (refused[0].error.line ?? 0) < beforeLine) {
+            const { title, error } = refused.shift();
+            const drop = droppedContent("section", title, modulePath, error);
+            flatItems.push(droppedSection("lens", drop));
+        }
+    };
     // Helper: process a section (LO or Lens). An LO import also yields the
     // outcome itself, so lenses can be tagged with it below.
     function processSection(section, _subsectionLevel) {
@@ -476,9 +501,10 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
         const { sections, outcome } = processSection(section);
         recordOutcome(outcome, true);
         moduleLevelTestSections.push(...sections);
-        return sections.length;
+        return sections.filter(isBuilt).length;
     }
     for (const section of parsedModule.sections) {
+        placeRefused(section.line);
         if (section.type === "submodule") {
             if (seenSubmodule)
                 groupIdx++;
@@ -493,6 +519,7 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
             // Process children
             if (section.children) {
                 for (const child of section.children) {
+                    placeRefused(child.line);
                     const { sections, outcome } = processSection(child, child.level + 1);
                     recordOutcome(outcome, false);
                     flatItems.push(...sections);
@@ -537,13 +564,31 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
             flatItems.push(...sections);
         }
     }
+    placeRefused();
     // Flat modules: append top-declared LO tests at the end of the section list.
     if (!hasSubmodules) {
         flatItems.push(...moduleLevelTestSections);
     }
     // Validate and split at boundaries
-    const boundaryErrors = validateBoundaries(flatItems, modulePath);
+    const boundaryErrors = validateBoundaries(flatItems.filter(isBuilt), modulePath);
     errors.push(...boundaryErrors);
+    // Sections before the first `# Submodule:` are on no page. Each is recorded
+    // before the first page's sections: a built one with the error that says
+    // so, a placeholder with its own (src/dropped.ts).
+    const firstBoundary = flatItems.findIndex(isBoundary);
+    const outsideItems = flatItems.slice(0, Math.max(firstBoundary, 0));
+    const outside = boundaryErrors.find((e) => e.message === OUTSIDE_SUBMODULES);
+    const orphans = [];
+    for (const section of outsideItems) {
+        if (!isBuilt(section))
+            orphans.push(...placeDropped([section]).items);
+        else if (outside) {
+            const sourcePath = section.sourcePath ?? modulePath;
+            const title = section.meta.title || fileStem(sourcePath);
+            const drop = droppedContent("section", title, sourcePath, outside);
+            orphans.push(placedAfter(-1, [], drop));
+        }
+    }
     const groups = splitAtBoundaries(flatItems, parsedModule.slug, parsedModule.title);
     // groups[i] is the i-th `# Submodule:` (the whole module when flat), the
     // same order recordOutcome counted in.
@@ -572,7 +617,7 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
         }
     }
     // Module-level LOs: append the synthesized "Test Your Understanding" entry.
-    if (hasSubmodules && moduleLevelTestSections.length > 0) {
+    if (hasSubmodules && moduleLevelTestSections.some(isBuilt)) {
         const testSlug = `${parsedModule.slug}/test-your-understanding`;
         const collision = groups.find((g) => g.slug === testSlug);
         if (collision) {
@@ -596,16 +641,22 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
             });
         }
     }
-    const resultModules = groups.map((g) => ({
+    else if (hasSubmodules && moduleLevelTestSections.length > 0) {
+        // Every module-level test failed, so there is no test page: their
+        // records follow the last page.
+        groups[groups.length - 1].sections.push(...moduleLevelTestSections);
+    }
+    const placed = groups.map((g) => placeDropped(g.sections));
+    placed[0].items.unshift(...orphans);
+    const resultModules = groups.map((g, i) => ({
         slug: g.slug,
         title: g.title,
         contentId: parsedModule.contentId,
-        sections: g.sections,
+        sections: placed[i].sections,
         sourcePath: modulePath,
         ...(g.parentSlug
             ? { parentSlug: g.parentSlug, parentTitle: g.parentTitle }
             : {}),
-        ...(moduleError ? { error: moduleError } : {}),
         // Module-level add_to_ai_context, with any submodule-level entries merged in
         // (module first, deduped). When the submodule has no field, this is exactly
         // the module's own value.
@@ -627,42 +678,80 @@ export function flattenModule(modulePath, files, visitedPaths = new Set(), tierM
             : primaryModule,
         modules: resultModules,
         errors,
+        dropped: placed.map((p) => p.items),
     };
 }
+/**
+ * The sections a module declares, for the cross-check in src/dropped.ts:
+ * every lens import, and every outcome import except one whose outcome
+ * declares no test segment (that builds nothing, on purpose). A section's page
+ * is the index of its `# Submodule:` (0 outside any). Paths resolve as
+ * flattenLensSection and flattenLearningOutcomeSection resolve them, so a
+ * section and its record name the same file.
+ */
+export function declaredSections(parsedModule, modulePath, files) {
+    const declared = [];
+    const pathOf = (source) => {
+        const link = source ? parseWikilink(source, modulePath) : null;
+        if (!link || link.error)
+            return modulePath;
+        const resolved = resolveWikilinkPath(link.path, modulePath);
+        return findFileWithExtension(resolved, files) ?? resolved;
+    };
+    const declare = (section, page) => {
+        const sourcePath = pathOf(section.fields.source);
+        const own = sourcePath === modulePath;
+        if (section.type === "lens") {
+            const title = section.title.trim() || (own ? "Lens" : fileStem(sourcePath));
+            declared.push({ sourcePath, title, line: section.line, page });
+        }
+        else if (section.type === "learning-outcome") {
+            if (!own && files.has(sourcePath)) {
+                const text = files.get(sourcePath);
+                const outcome = parseLearningOutcome(text, sourcePath).learningOutcome;
+                const test = outcome?.test;
+                const declaresSegments = !!test && test.segments.length + droppedSegmentsOf(test).length > 0;
+                if (outcome && !declaresSegments)
+                    return;
+            }
+            const title = own ? "Test" : `Test: ${fileStem(sourcePath)}`;
+            declared.push({ sourcePath, title, line: section.line, page });
+        }
+    };
+    // A section after the k-th `# Submodule:` marker, nested or not, is on
+    // page k.
+    let page = 0;
+    let submodules = 0;
+    for (const section of parsedModule.sections) {
+        if (section.type !== "submodule")
+            declare(section, page);
+        else {
+            page = submodules++;
+            for (const child of section.children ?? [])
+                declare(child, page);
+        }
+    }
+    return declared;
+}
 /** Minutes a learning-outcome test takes to write when its outcome sets no
  * `writing_minutes`: one figure per test, whatever its question count. */
 const TEST_WRITING_MINUTES = 7;
 /**
  * Build a test Section from a ParsedTestRef with inline segments. Its time is
  * writing time, carried as durationMinutes (a total with no tutor share).
+ * `dropped` are the segments that errors left out; when they were all of
+ * them, there is no section, and they say why.
  */
 function buildTestSection(testRef, writingMinutes, outcome, loPath, files, visitedPaths, tierMap, errors) {
-    if (!testRef.segments.length)
-        return null;
-    const testSegments = [];
-    const blockTargets = collectBlockTargetsFrom(testRef.segments.flatMap((segment) => "content" in segment && typeof segment.content === "string"
-        ? [segment.content]
-        : []));
     // collapsed: false — test sections never carried collapsed_* fields
-    const articlePlan = planLensArticles(testRef.segments, loPath, files, new Set(visitedPaths), tierMap, { collapsed: false });
-    for (let i = 0; i < testRef.segments.length; i++) {
-        const parsedSegment = testRef.segments[i];
-        const planned = articlePlan.get(i);
-        if (planned) {
-            errors.push(...planned.errors);
-            for (const segment of planned.segments) {
-                testSegments.push(prependFrames(segment, parsedSegment.frames));
-            }
-            continue;
-        }
-        const segmentResult = convertSegment(parsedSegment, loPath, files, new Set(visitedPaths), tierMap, blockTargets);
-        errors.push(...segmentResult.errors);
-        if (segmentResult.segment) {
-            testSegments.push(prependFrames(segmentResult.segment, parsedSegment.frames));
-        }
-    }
+    const flat = flattenSegments(testRef, loPath, files, visitedPaths, tierMap, {
+        collapsed: false,
+    });
+    errors.push(...flat.errors);
+    const { dropped } = flat;
+    const testSegments = flat.segments;
     if (testSegments.length === 0)
-        return null;
+        return { section: null, dropped };
     const hasFeedback = testSegments.some((s) => s.type === "question" && s.feedback);
     // Grouped feedback is the legacy questions' feedback; force-feedback:: on
     // any of them sends it on completion instead of on "Get feedback". The
@@ -673,7 +762,7 @@ function buildTestSection(testRef, writingMinutes, outcome, loPath, files, visit
         : forced.includes(true)
             ? true
             : forced[0];
-    return {
+    const section = {
         type: "test",
         // Always the outcome's name: the sidebar shows it, and the title is the
         // section's URL anchor, so two tests in one submodule must differ.
@@ -687,14 +776,15 @@ function buildTestSection(testRef, writingMinutes, outcome, loPath, files, visit
         learningOutcomes: [outcome],
         durationMinutes: writingMinutes ?? TEST_WRITING_MINUTES,
     };
+    return { section, dropped };
 }
 /** Tag a lens section with every outcome that suggests its file. An inline
  * lens's sourcePath is the module file, which no outcome suggests. */
-function tagLensOutcomes(section, outcomes) {
+export function tagLensOutcomes(section, outcomes) {
     if (section.type !== "lens" || !section.sourcePath)
         return;
     for (const { ref, lensPaths } of outcomes) {
-        if (!lensPaths.has(section.sourcePath))
+        if (!lensPaths.includes(section.sourcePath))
             continue;
         if (section.learningOutcomes.some((o) => o.id === ref.id))
             continue;
@@ -709,32 +799,7 @@ export function suggestedLensPaths(lo, files) {
         if (resolved)
             lensPaths.add(resolved);
     }
-    return lensPaths;
-}
-/**
- * A course teaches an outcome across units but tests it once, so a lens also
- * carries every outcome that suggests it and is tested in any module of a
- * course the lens's module is in. Runs after flattening, once the course
- * progressions are resolved to module slugs; tags from the lens's own
- * submodule come first, and the ones added here are marked testedElsewhere.
- */
-export function tagCourseOutcomes(modules, courses, lensPathsOf) {
-    const moduleBySlug = new Map(modules.map((mod) => [mod.slug, mod]));
-    for (const course of courses) {
-        const courseModules = course.progression.flatMap((item) => {
-            const mod = item.slug ? moduleBySlug.get(item.slug) : undefined;
-            return item.type === "module" && mod ? [mod] : [];
-        });
-        const sections = courseModules.flatMap((mod) => mod.sections);
-        const outcomes = sections.flatMap((section) => section.type === "test" && section.sourcePath
-            ? section.learningOutcomes.map((ref) => ({
-                ref: { ...ref, testedElsewhere: true },
-                lensPaths: lensPathsOf(section.sourcePath),
-            }))
-            : []);
-        for (const section of sections)
-            tagLensOutcomes(section, outcomes);
-    }
+    return [...lensPaths];
 }
 /**
  * Flatten a Learning Outcome section from a module file.
@@ -771,6 +836,18 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
             });
         }
     }
+    // An import that fails makes no test: a placeholder stands where the test
+    // would have been, with the error that stopped it (src/dropped.ts).
+    const failed = (sourcePath, cause = errors.at(-1)) => ({
+        sections: cause
+            ? [
+                droppedSection("test", droppedContent("section", sourcePath === modulePath
+                    ? "Test"
+                    : `Test: ${fileStem(sourcePath)}`, sourcePath, cause)),
+            ]
+            : [],
+        errors,
+    });
     // Get the source wikilink
     const source = section.fields.source;
     if (!source) {
@@ -781,7 +858,7 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
             suggestion: "Add 'source:: [[../Learning Outcomes/filename.md|Display]]'",
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(modulePath);
     }
     // Parse and resolve the wikilink
     const wikilink = parseWikilink(source, modulePath);
@@ -798,7 +875,7 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
             suggestion,
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(modulePath);
     }
     const loPathResolved = resolveWikilinkPath(wikilink.path, modulePath);
     const loPath = findFileWithExtension(loPathResolved, files);
@@ -814,7 +891,7 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
             suggestion,
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(loPathResolved);
     }
     // Check tier violation (module -> LO)
     if (tierMap) {
@@ -825,7 +902,7 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
             errors.push(violation);
         }
         if (childTier === "ignored") {
-            return { sections: [], errors };
+            return failed(loPath, violation);
         }
     }
     // Check for circular reference
@@ -836,7 +913,7 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
             message: `Circular reference detected: ${loPath}`,
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(loPath);
     }
     visitedPaths.add(loPath);
     const loContent = files.get(loPath);
@@ -844,7 +921,7 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
     const loResult = parseLearningOutcome(loContent, loPath);
     errors.push(...loResult.errors);
     if (!loResult.learningOutcome) {
-        return { sections: [], errors };
+        return failed(loPath, dropCause(loResult.errors));
     }
     const lo = loResult.learningOutcome;
     // Suggested lenses are validated standalone in processContent; here they
@@ -857,9 +934,11 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
     const lensPaths = suggestedLensPaths(lo, files);
     // Emit the test section if the LO has one with inline segments
     if (lo.test) {
-        const testSection = buildTestSection(lo.test, lo.writingMinutes, ref, loPath, files, visitedPaths, tierMap, errors);
-        if (testSection)
-            sections.push(testSection);
+        const { section: test, dropped } = buildTestSection(lo.test, lo.writingMinutes, ref, loPath, files, visitedPaths, tierMap, errors);
+        if (test)
+            sections.push(attachDroppedSegments(test, dropped));
+        else if (dropped.length > 0)
+            sections.push(...failed(loPath, dropped[0].error).sections);
     }
     return { sections, errors, outcome: { ref, lensPaths } };
 }
@@ -870,9 +949,22 @@ function flattenLearningOutcomeSection(section, modulePath, files, visitedPaths,
 function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, inlineLens) {
     const errors = [];
     const sections = [];
+    // A lens that fails makes no section: a placeholder stands where it would
+    // have been, with the error that stopped it (src/dropped.ts).
+    const failed = (sourcePath, cause = errors.at(-1)) => ({
+        sections: cause
+            ? [
+                droppedSection("lens", droppedContent("section", section.title.trim() ||
+                    (sourcePath === modulePath ? "Lens" : fileStem(sourcePath)), sourcePath, cause)),
+            ]
+            : [],
+        errors,
+    });
     // Inline lens: has id:: + segments (no source:: at section level)
     if (inlineLens) {
-        const { segments, errors: flattenErrors } = flattenSingleLens(inlineLens, modulePath, files, visitedPaths, tierMap);
+        const { segments, errors: flattenErrors, dropped, } = flattenSegments(inlineLens, modulePath, files, visitedPaths, tierMap, {
+            collapsed: true,
+        });
         errors.push(...flattenErrors);
         const resultSection = attachSourceLine({
             type: "lens",
@@ -881,7 +973,7 @@ function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, i
             ...lensPlacementFields(section.fields, modulePath, section.line, errors),
             ...lensSectionFields(inlineLens, segments, modulePath, section.line, errors),
         }, section.line);
-        sections.push(resultSection);
+        sections.push(attachDroppedSegments(resultSection, dropped));
         return { sections, errors };
     }
     // Referenced lens: has source:: at section level
@@ -894,7 +986,7 @@ function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, i
             suggestion: "Add 'source:: [[../Lenses/filename.md|Display]]' or 'id:: <uuid>' with #### segments",
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(modulePath);
     }
     // Parse and resolve the wikilink
     const wikilink = parseWikilink(source, modulePath);
@@ -911,7 +1003,7 @@ function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, i
             suggestion,
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(modulePath);
     }
     const lensPathResolved = resolveWikilinkPath(wikilink.path, modulePath);
     const lensPath = findFileWithExtension(lensPathResolved, files);
@@ -925,7 +1017,7 @@ function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, i
             suggestion,
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(lensPathResolved);
     }
     // Check tier violation
     if (tierMap) {
@@ -936,7 +1028,7 @@ function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, i
             errors.push(violation);
         }
         if (childTier === "ignored") {
-            return { sections: [], errors };
+            return failed(lensPath, violation);
         }
     }
     // Check for circular reference
@@ -946,17 +1038,19 @@ function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, i
             message: `Circular reference detected: ${lensPath}`,
             severity: "error",
         });
-        return { sections: [], errors };
+        return failed(lensPath);
     }
     visitedPaths.add(lensPath);
     const lensContent = files.get(lensPath);
     const lensResult = parseLens(lensContent, lensPath, files);
     errors.push(...lensResult.errors);
     if (!lensResult.lens) {
-        return { sections: [], errors };
+        return failed(lensPath, dropCause(lensResult.errors));
     }
     const lens = lensResult.lens;
-    const { segments, errors: flattenErrors } = flattenSingleLens(lens, lensPath, files, visitedPaths, tierMap);
+    const { segments, errors: flattenErrors, dropped, } = flattenSegments(lens, lensPath, files, visitedPaths, tierMap, {
+        collapsed: true,
+    });
     errors.push(...flattenErrors);
     const resultSection = attachSourceLine({
         type: "lens",
@@ -965,7 +1059,7 @@ function flattenLensSection(section, modulePath, files, visitedPaths, tierMap, i
         ...lensPlacementFields(section.fields, modulePath, section.line, errors),
         ...lensSectionFields(lens, segments, lensPath, section.line, errors),
     }, getSourceLine(lens));
-    sections.push(resultSection);
+    sections.push(attachDroppedSegments(resultSection, dropped));
     return { sections, errors };
 }
 /**
@@ -1187,7 +1281,7 @@ function planLensArticles(parsedSegments, lensPath, files, visitedPaths, tierMap
         const parsedSegment = parsedSegments[i];
         if (parsedSegment.type !== "article")
             continue;
-        const entry = { segments: [], errors: [] };
+        const entry = { segments: [], errors: [], dropped: [] };
         plan.set(i, entry);
         // Source comes from the parsed segment (set via inheritance in parseLens)
         if (!parsedSegment.source) {
@@ -1253,22 +1347,32 @@ function planLensArticles(parsedSegments, lensPath, files, visitedPaths, tierMap
         group.indices.push(i);
         group.segments.push(parsedSegment);
     }
+    // A segment that joined no group was left out by the error it reported.
+    const grouped = new Set([...groups.values()].flatMap((g) => g.indices));
+    for (const [i, entry] of plan) {
+        if (grouped.has(i))
+            continue;
+        entry.dropped.push(...droppedSegment("article", sourceOf(parsedSegments[i]), lensPath, entry.errors));
+    }
     for (const [articlePath, group] of groups) {
         const articleContent = files.get(articlePath);
         const articleFrontmatter = parseFrontmatter(articleContent, articlePath);
         const fm = articleFrontmatter.frontmatter;
-        const blockTargets = collectBlockTargets(articleFrontmatter.body);
+        const blockTargets = lazyBlockTargets(() => collectBlockTargets(articleFrontmatter.body));
+        const articleTitle = typeof fm.title === "string" ? fm.title : fileStem(articlePath);
         const resolved = resolveArticleSource(articleContent, group.segments.map((ps) => ({ from: ps.fromAnchor, to: ps.toAnchor })), articlePath);
         for (let k = 0; k < group.segments.length; k++) {
             const parsedSegment = group.segments[k];
             const entry = plan.get(group.indices[k]);
             const excerpt = resolved[k];
             if (excerpt.error) {
-                entry.errors.push({
+                const error = {
                     ...excerpt.error,
                     file: lensPath,
                     line: getSourceLine(parsedSegment),
-                });
+                };
+                entry.errors.push(error);
+                entry.dropped.push(droppedContent("segment", articleTitle, articlePath, error));
                 continue;
             }
             if (excerpt.warning) {
@@ -1330,6 +1434,8 @@ function planLensArticles(parsedSegments, lensPath, files, visitedPaths, tierMap
             // by the lifted callouts it sits in.
             const partSegments = [];
             let elementFailed = false;
+            // Each element, with the errors of its failure when it failed.
+            const elements = [];
             for (const part of excerpt.parts) {
                 if (part.kind === "prose") {
                     const segment = makeArticleSegment(part.content);
@@ -1343,9 +1449,9 @@ function planLensArticles(parsedSegments, lensPath, files, visitedPaths, tierMap
                 // The element is the RawSegment its `####` twin would be: the same
                 // parser and flattener conversions apply, resolved from the article.
                 // Its field errors were reported in the article's own parse pass.
-                const parsed = parseRawSegment(part.raw, "lens", articlePath).segment;
-                const converted = parsed &&
-                    convertSegment(parsed, articlePath, files, visitedPaths, tierMap, new Map(), {
+                const parse = parseRawSegment(part.raw, "lens", articlePath);
+                const converted = parse.segment &&
+                    convertSegment(parse.segment, articlePath, files, visitedPaths, tierMap, new Map(), {
                         errorLine: findImportLine(articleContent, part.rawLine),
                         notFoundCode: `article.${ARTICLE_ELEMENT_KINDS[part.raw.type].code}-not-found`,
                     });
@@ -1353,8 +1459,13 @@ function planLensArticles(parsedSegments, lensPath, files, visitedPaths, tierMap
                     entry.errors.push(...converted.errors);
                 if (!converted?.segment) {
                     elementFailed = true;
+                    elements.push({
+                        raw: part.raw,
+                        failure: converted ? converted.errors : parse.errors,
+                    });
                     continue;
                 }
+                elements.push({ raw: part.raw });
                 const segment = converted.segment;
                 if (segment.type === "video" ||
                     segment.type === "widget" ||
@@ -1369,10 +1480,23 @@ function planLensArticles(parsedSegments, lensPath, files, visitedPaths, tierMap
             if (elementFailed) {
                 // A broken element must not leave a half-split article with dangling
                 // seam flags: fall back to the un-split excerpt (error already
-                // recorded above).
+                // recorded above). Every element of the excerpt is lost with the
+                // split: a failed one by its own error, the others by the first.
                 const segment = makeArticleSegment(excerpt.content);
                 applyCollapsed([segment]);
                 entry.segments.push(segment);
+                const causeOf = (failure) => failure && dropCause(failure);
+                const firstCause = elements
+                    .map((e) => causeOf(e.failure))
+                    .find(Boolean);
+                for (const { raw, failure } of elements) {
+                    const cause = causeOf(failure) ?? firstCause;
+                    if (!cause)
+                        continue;
+                    entry.dropped.push(...droppedSegment(raw.type, raw.fields.source, articlePath, [
+                        cause,
+                    ]));
+                }
                 continue;
             }
             applyCollapsed(partSegments);
@@ -1840,7 +1964,7 @@ origin) {
 export function flattenStandaloneArticle(articlePath, files, tierMap) {
     const fileName = articlePath.slice(articlePath.lastIndexOf("/") + 1);
     const plan = planLensArticles([{ type: "article", source: `[[${fileName}]]` }], articlePath, files, new Set(), tierMap, { collapsed: false });
-    return plan.get(0) ?? { segments: [], errors: [] };
+    return plan.get(0);
 }
 /**
  * Flatten a single Lens file into a FlattenedModule.
@@ -1849,7 +1973,7 @@ export function flattenLens(lensPath, files, tierMap, preParsedLens) {
     const errors = [];
     // Skip ignored lenses
     if (tierMap?.get(lensPath) === "ignored") {
-        return { module: null, modules: [], errors };
+        return { module: null, modules: [], errors, dropped: [] };
     }
     const lensContent = files.get(lensPath);
     if (!lensContent) {
@@ -1858,7 +1982,7 @@ export function flattenLens(lensPath, files, tierMap, preParsedLens) {
             message: `Lens file not found: ${lensPath}`,
             severity: "error",
         });
-        return { module: null, modules: [], errors };
+        return { module: null, modules: [], errors, dropped: [] };
     }
     // Use pre-parsed lens if provided, otherwise parse
     const lens = preParsedLens ??
@@ -1868,11 +1992,13 @@ export function flattenLens(lensPath, files, tierMap, preParsedLens) {
             return lensResult.lens;
         })();
     if (!lens) {
-        return { module: null, modules: [], errors };
+        return { module: null, modules: [], errors, dropped: [] };
     }
     const visitedPaths = new Set([lensPath]);
     // Flatten lens segments using shared helper
-    const { segments, errors: flattenErrors } = flattenSingleLens(lens, lensPath, files, visitedPaths, tierMap);
+    const { segments, errors: flattenErrors, dropped, } = flattenSegments(lens, lensPath, files, visitedPaths, tierMap, {
+        collapsed: true,
+    });
     errors.push(...flattenErrors);
     // Derive title: frontmatter > first article/video segment > filename
     const meta = {};
@@ -1896,13 +2022,13 @@ export function flattenLens(lensPath, files, tierMap, preParsedLens) {
                 .replace(/\b\w/g, (c) => c.toUpperCase());
         }
     }
-    const section = {
+    const section = attachDroppedSegments({
         type: "lens",
         meta,
         sourcePath: lensPath,
         optional: false,
         ...lensSectionFields(lens, segments, lensPath, 1, errors),
-    };
+    }, dropped);
     const flattenedModule = {
         slug: "lens/" + fileNameToSlug(lensPath),
         title: meta.title ?? fileNameToSlug(lensPath),
@@ -1910,6 +2036,11 @@ export function flattenLens(lensPath, files, tierMap, preParsedLens) {
         sections: [section],
         sourcePath: lensPath,
     };
-    return { module: flattenedModule, modules: [flattenedModule], errors };
+    return {
+        module: flattenedModule,
+        modules: [flattenedModule],
+        errors,
+        dropped: [placeDropped([section]).items],
+    };
 }
 //# sourceMappingURL=index.js.map