@cesarandreslopez/occ 0.8.12 → 0.9.1

package/dist/src/workspace/bundle.js

@@ -1,15 +1,20 @@
+import { fork } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { analyzeWorkspace } from './analyze.js';
 import { describeWorkspace } from './describe.js';
 import { inspectWorkspaceDocumentSet } from './documents.js';
+import { readSectionedWorkspaceBundle } from './bundle-io.js';
 import { buildCodebaseIndexIsolated } from '../code/isolated.js';
 import { previewCodebaseSize } from '../code/preview.js';
 import { openCodeIndexStore } from '../code/store.js';
-import { slimifyIndex } from '../code/slim.js';
-import { chunkFromIndex } from '../code/chunk.js';
-import { chunkDocument, chunkDocumentFromMarkdown } from '../doc/chunk.js';
-import { abortIfNeeded, mapWithConcurrency, normalizeRelativePath } from '../utils.js';
-import { isOccAbortError } from '../errors.js';
+import { slimifyIndex, slimifyIndexCooperative } from '../code/slim.js';
+import { chunkFromIndex, chunkFromIndexCooperative } from '../code/chunk.js';
+import { chunkDocument, chunkDocumentFromMarkdown, } from '../doc/chunk.js';
+import { abortIfNeeded, createYielder, isCooperative, mapWithConcurrency, normalizeRelativePath, sanitizeForkExecArgv, } from '../utils.js';
+import { OccAbortError, isOccAbortError } from '../errors.js';
 const DEFAULT_EXCLUDE_DIR = ['node_modules', '.git', 'dist', 'vendor', 'build', 'coverage', 'target'];
 // Step descriptors shared by the sequential and concurrent phase paths.
 const STEP_DESCRIPTION = { phase: 'description', detail: 'Describe workspace' };
@@ -68,7 +73,9 @@ function buildOutline(rootDir, description, documents, codeIndex) {
             continue;
         moduleCounts.set(firstSegment, (moduleCounts.get(firstSegment) ?? 0) + 1);
     }
-    for (const [modulePath, files] of [...moduleCounts.entries()].sort((left, right) => right[1] - left[1]).slice(0, 20)) {
+    for (const [modulePath, files] of [...moduleCounts.entries()]
+        .sort((left, right) => right[1] - left[1])
+        .slice(0, 20)) {
         root.children.push({
             id: `module:${modulePath}`,
             kind: 'module',
@@ -89,7 +96,7 @@ function buildOutline(rootDir, description, documents, codeIndex) {
                 tokenEstimate: doc.tokenEstimate,
                 headingCount: doc.headingCount,
             },
-            children: doc.topLevelSections.map((section) => ({
+            children: doc.topLevelSections.map(section => ({
                 id: `section:${doc.relativePath}:${section}`,
                 kind: 'section',
                 title: section,
@@ -107,18 +114,20 @@ function detectCodeDocumentReferences(codeIndex, documents, limit) {
     if (!codeIndex || !documents || limit <= 0)
         return [];
     const symbolNodes = codeIndex.nodes
-        .filter((node) => ['class', 'interface', 'type-alias', 'enum', 'function'].includes(node.type))
-        .filter((node) => node.name.length >= 3)
-        .sort((left, right) => (right.name.length - left.name.length) || left.name.localeCompare(right.name));
+        .filter(node => ['class', 'interface', 'type-alias', 'enum', 'function'].includes(node.type))
+        .filter(node => node.name.length >= 3)
+        .sort((left, right) => right.name.length - left.name.length || left.name.localeCompare(right.name));
     const seenNames = new Set();
-    const symbols = symbolNodes.filter((node) => {
+    const symbols = symbolNodes
+        .filter(node => {
         if (seenNames.has(node.name))
             return false;
         seenNames.add(node.name);
         return true;
-    }).slice(0, 1_000);
+    })
+        .slice(0, 1_000);
     // Compile each symbol pattern once instead of per line.
-    const compiled = symbols.map((symbol) => ({
+    const compiled = symbols.map(symbol => ({
         symbol,
         pattern: new RegExp(`\\b${escapeRegExp(symbol.name)}\\b`),
     }));
@@ -128,7 +137,7 @@ function detectCodeDocumentReferences(codeIndex, documents, limit) {
     let prescreen = null;
     if (symbols.length > 0) {
         try {
-            prescreen = new RegExp(`\\b(?:${symbols.map((symbol) => escapeRegExp(symbol.name)).join('|')})\\b`);
+            prescreen = new RegExp(`\\b(?:${symbols.map(symbol => escapeRegExp(symbol.name)).join('|')})\\b`);
         }
         catch {
             prescreen = null; // Fall back to scanning every line with the compiled patterns.
@@ -164,7 +173,77 @@ function detectCodeDocumentReferences(codeIndex, documents, limit) {
     }
     return references;
 }
-async function buildDocumentChunks(documents, options, onProgress) {
+async function detectCodeDocumentReferencesCooperative(codeIndex, documents, limit, yielder) {
+    if (!codeIndex || !documents || limit <= 0)
+        return [];
+    const symbolNodes = codeIndex.nodes
+        .filter(node => ['class', 'interface', 'type-alias', 'enum', 'function'].includes(node.type))
+        .filter(node => node.name.length >= 3)
+        .sort((left, right) => right.name.length - left.name.length || left.name.localeCompare(right.name));
+    const seenNames = new Set();
+    const symbols = symbolNodes
+        .filter(node => {
+        if (seenNames.has(node.name))
+            return false;
+        seenNames.add(node.name);
+        return true;
+    })
+        .slice(0, 1_000);
+    const compiled = symbols.map(symbol => ({
+        symbol,
+        pattern: new RegExp(`\\b${escapeRegExp(symbol.name)}\\b`),
+    }));
+    let prescreen = null;
+    if (symbols.length > 0) {
+        try {
+            prescreen = new RegExp(`\\b(?:${symbols.map(symbol => escapeRegExp(symbol.name)).join('|')})\\b`);
+        }
+        catch {
+            prescreen = null;
+        }
+    }
+    const references = [];
+    for (const doc of documents.documents) {
+        if (!doc.markdownContent) {
+            await yielder.tick();
+            continue;
+        }
+        const lines = doc.markdownContent.split(/\r?\n/);
+        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+            const line = lines[lineIndex];
+            if (!line.trim()) {
+                if ((lineIndex + 1) % 2_000 === 0)
+                    await yielder.tick();
+                continue;
+            }
+            if (prescreen && !prescreen.test(line)) {
+                if ((lineIndex + 1) % 2_000 === 0)
+                    await yielder.tick();
+                continue;
+            }
+            for (const { symbol, pattern } of compiled) {
+                if (!pattern.test(line))
+                    continue;
+                references.push({
+                    documentPath: doc.relativePath,
+                    symbolName: symbol.name,
+                    symbolType: symbol.type,
+                    symbolPath: symbol.relativePath ?? normalizeRelativePath(path.relative(codeIndex.repoRoot, symbol.path)),
+                    symbolLine: symbol.line,
+                    line: lineIndex + 1,
+                    context: line.trim().slice(0, 240),
+                });
+                if (references.length >= limit)
+                    return references;
+            }
+            if ((lineIndex + 1) % 2_000 === 0)
+                await yielder.tick();
+        }
+        await yielder.tick();
+    }
+    return references;
+}
+async function buildDocumentChunks(documents, options, onProgress, yielder) {
     if (!documents)
         return [];
     const maxChunks = options.maxDocumentChunks ?? 500;
@@ -183,19 +262,20 @@ async function buildDocumentChunks(documents, options, onProgress) {
             return undefined;
         let docChunks;
         try {
-            docChunks = doc.markdownContent != null
-                // Markdown was already produced by document inspection — reuse it
-                // instead of re-reading and re-converting the file. Per-document
-                // values are spread last so caller chunk options cannot clobber them.
-                ? chunkDocumentFromMarkdown(doc.markdownContent, {
-                    ...options.chunk,
-                    filePath: doc.filePath,
-                    relativePath: doc.relativePath,
-                })
-                : await chunkDocument(doc.filePath, {
-                    ...options.chunk,
-                    relativePath: doc.relativePath,
-                });
+            docChunks =
+                doc.markdownContent != null
+                    ? // Markdown was already produced by document inspection — reuse it
+                        // instead of re-reading and re-converting the file. Per-document
+                        // values are spread last so caller chunk options cannot clobber them.
+                        chunkDocumentFromMarkdown(doc.markdownContent, {
+                            ...options.chunk,
+                            filePath: doc.filePath,
+                            relativePath: doc.relativePath,
+                        })
+                    : await chunkDocument(doc.filePath, {
+                        ...options.chunk,
+                        relativePath: doc.relativePath,
+                    });
         }
         catch {
             // Document conversion errors are already represented in inspectDocuments.
@@ -210,6 +290,8 @@ async function buildDocumentChunks(documents, options, onProgress) {
             currentPath: doc.filePath,
             scope: 'document',
         });
+        if (yielder)
+            await yielder.tick();
         return docChunks;
     }, options.signal);
     const chunks = [];
@@ -219,13 +301,13 @@ async function buildDocumentChunks(documents, options, onProgress) {
     }
     return chunks.slice(0, maxChunks);
 }
-function buildCodeChunks(codeIndex, options, onProgress) {
+async function buildCodeChunks(codeIndex, options, onProgress, yielder) {
     if (!codeIndex)
         return [];
-    const chunks = chunkFromIndex(codeIndex, options.codeChunk);
-    const capped = options.maxCodeChunks != null
-        ? chunks.slice(0, Math.max(0, options.maxCodeChunks))
-        : chunks;
+    const chunks = yielder
+        ? await chunkFromIndexCooperative(codeIndex, options.codeChunk, yielder)
+        : chunkFromIndex(codeIndex, options.codeChunk);
+    const capped = options.maxCodeChunks != null ? chunks.slice(0, Math.max(0, options.maxCodeChunks)) : chunks;
     onProgress?.({
         phase: 'code-chunk',
         total: capped.length,
@@ -253,7 +335,7 @@ function mapCodeChunk(chunk) {
 }
 function mapDocumentChunksToCorpus(chunks) {
     const perFileIndex = new Map();
-    return chunks.map((chunk) => {
+    return chunks.map(chunk => {
         const chunkIndex = perFileIndex.get(chunk.relativePath) ?? 0;
         perFileIndex.set(chunk.relativePath, chunkIndex + 1);
         return {
@@ -274,19 +356,172 @@ function mapDocumentChunksToCorpus(chunks) {
         };
     });
 }
-function buildCorpusChunks(codeChunks, documentChunks, options) {
+async function buildCorpusChunks(codeChunks, documentChunks, options, yielder) {
     if (!options.includeCorpusChunks)
         return undefined;
-    const chunks = [
-        ...(codeChunks ?? []).map(mapCodeChunk),
-        ...mapDocumentChunksToCorpus(documentChunks ?? []),
-    ].sort((left, right) => (left.relativePath.localeCompare(right.relativePath)
-        || left.kind.localeCompare(right.kind)
-        || left.chunkIndex - right.chunkIndex));
+    let chunks;
+    if (!yielder) {
+        chunks = [...(codeChunks ?? []).map(mapCodeChunk), ...mapDocumentChunksToCorpus(documentChunks ?? [])];
+    }
+    else {
+        chunks = [];
+        let mapped = 0;
+        for (const chunk of codeChunks ?? []) {
+            chunks.push(mapCodeChunk(chunk));
+            if (++mapped % 512 === 0)
+                await yielder.tick();
+        }
+        const perFileIndex = new Map();
+        for (const chunk of documentChunks ?? []) {
+            const chunkIndex = perFileIndex.get(chunk.relativePath) ?? 0;
+            perFileIndex.set(chunk.relativePath, chunkIndex + 1);
+            chunks.push({
+                kind: 'document',
+                chunkId: chunk.chunkId,
+                filePath: chunk.filePath,
+                relativePath: chunk.relativePath,
+                title: chunk.title,
+                content: chunk.content,
+                chunkIndex,
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                format: chunk.format,
+                headingPath: chunk.headingPath,
+                anchor: chunk.anchor,
+                tokenEstimate: chunk.tokenEstimate,
+                wordCount: chunk.wordCount,
+            });
+            if (++mapped % 512 === 0)
+                await yielder.tick();
+        }
+    }
+    chunks.sort((left, right) => left.relativePath.localeCompare(right.relativePath) ||
+        left.kind.localeCompare(right.kind) ||
+        left.chunkIndex - right.chunkIndex);
     const maxChunks = options.maxCorpusChunks;
     return maxChunks != null ? chunks.slice(0, Math.max(0, maxChunks)) : chunks;
 }
+function resolveBundleRunnerPath() {
+    const directory = path.dirname(fileURLToPath(import.meta.url));
+    const builtRunner = path.join(directory, 'bundle-runner.js');
+    if (existsSync(builtRunner))
+        return builtRunner;
+    return path.join(directory, 'bundle-runner.ts');
+}
+function serializableBundleOptions(options) {
+    const { signal: _signal, onProgress: _onProgress, store: _store, cooperative: _cooperative, ...rest } = options;
+    return {
+        ...rest,
+        offThread: false,
+        chunk: rest.chunk
+            ? {
+                maxTokens: rest.chunk.maxTokens,
+                overlapTokens: rest.chunk.overlapTokens,
+            }
+            : undefined,
+        codeChunk: rest.codeChunk
+            ? {
+                maxTokens: rest.codeChunk.maxTokens,
+                overlapTokens: rest.codeChunk.overlapTokens,
+                files: rest.codeChunk.files,
+            }
+            : undefined,
+    };
+}
+export async function bundleWorkspaceIsolated(rootDir, options = {}, onProgress) {
+    if (options.store) {
+        throw new Error('offThread bundle requires cacheDir or no store; a caller-provided store instance cannot cross the process boundary');
+    }
+    abortIfNeeded(options.signal);
+    const runnerPath = resolveBundleRunnerPath();
+    const progress = onProgress ?? options.onProgress;
+    const childOptions = serializableBundleOptions(options);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let abortTimer;
+        const child = fork(runnerPath, [], {
+            stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+            execArgv: sanitizeForkExecArgv(),
+        });
+        const cleanup = () => {
+            if (abortTimer)
+                clearTimeout(abortTimer);
+            options.signal?.removeEventListener('abort', handleAbort);
+        };
+        const rejectAbort = () => {
+            cleanup();
+            reject(new OccAbortError());
+        };
+        const handleAbort = () => {
+            if (settled)
+                return;
+            child.send({ type: 'abort' });
+            abortTimer = setTimeout(() => {
+                if (!settled)
+                    child.kill();
+            }, 1000);
+        };
+        options.signal?.addEventListener('abort', handleAbort, { once: true });
+        let stderr = '';
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('message', (msg) => {
+            if (msg.type === 'progress' && msg.event) {
+                progress?.(msg.event);
+            }
+            else if (msg.type === 'aborted') {
+                settled = true;
+                rejectAbort();
+            }
+            else if (msg.type === 'complete' && msg.resultPath) {
+                settled = true;
+                void (async () => {
+                    try {
+                        const bundle = await readSectionedWorkspaceBundle(msg.resultPath, options.signal);
+                        await rm(msg.resultPath, { recursive: true, force: true }).catch(() => undefined);
+                        cleanup();
+                        resolve(bundle);
+                    }
+                    catch (err) {
+                        cleanup();
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                })();
+            }
+            else if (msg.type === 'error') {
+                settled = true;
+                cleanup();
+                reject(new Error(msg.message ?? 'Off-thread bundle failed'));
+            }
+        });
+        child.on('error', err => {
+            settled = true;
+            cleanup();
+            reject(err);
+        });
+        child.on('close', code => {
+            if (settled)
+                return;
+            cleanup();
+            if (options.signal?.aborted) {
+                rejectAbort();
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`Bundle runner exited with code ${code}: ${stderr.trim()}`));
+            }
+            else {
+                reject(new Error('Bundle runner exited without sending a result'));
+            }
+        });
+        child.send({ type: 'start', rootDir: path.resolve(rootDir), options: childOptions });
+    });
+}
 export async function bundleWorkspace(rootDir, options = {}) {
+    if (options.offThread) {
+        return bundleWorkspaceIsolated(rootDir, options, options.onProgress);
+    }
     const startedAt = Date.now();
     const resolvedRoot = path.resolve(rootDir);
     const includeDescription = options.includeDescription !== false;
@@ -300,6 +535,8 @@ export async function bundleWorkspace(rootDir, options = {}) {
     const includeCodeDocumentReferences = options.includeCodeDocumentReferences ?? true;
     const concurrentPhases = options.concurrentPhases !== false;
     const onProgress = options.onProgress;
+    const cooperative = isCooperative(options.cooperative);
+    const yielder = cooperative ? createYielder(options.cooperative, options.signal) : undefined;
     const errors = [];
     const shared = commonWorkspaceOptions(options);
     const steps = [
@@ -313,36 +550,36 @@ export async function bundleWorkspace(rootDir, options = {}) {
         STEP_OUTLINE,
     ];
     let completedSteps = 0;
-    const scopedCodeProgress = (event) => onProgress?.({ ...event, scope: event.scope ?? 'code' });
+    const scopedCodeProgress = event => onProgress?.({ ...event, scope: event.scope ?? 'code' });
     // Resolves the code index either through a persistent store (cacheDir/store
     // options — cache hits skip parsing, misses build in-process) or through the
     // pre-existing isolated subprocess build.
     const acquireCodeIndex = async () => {
         const slim = options.slimCodeIndex ?? true;
-        const contentMode = shouldBuildCodeChunks
-            ? 'full'
-            : (options.contentMode ?? (slim ? 'none' : 'excerpt'));
+        const contentMode = shouldBuildCodeChunks ? 'full' : (options.contentMode ?? (slim ? 'none' : 'excerpt'));
         if (options.store || options.cacheDir) {
-            const store = options.store ?? openCodeIndexStore({
-                repoRoot: resolvedRoot,
-                cacheDir: options.cacheDir,
-                excludeDir: shared.excludeDir,
-                noGitignore: shared.noGitignore,
-                ignorePatterns: shared.ignorePatterns,
-                overlayIgnorePatterns: shared.overlayIgnorePatterns,
-                contentMode,
-                maxFiles: options.maxCodeFiles,
-                maxBytes: options.maxCodeBytes,
-                onBudgetExceeded: 'truncate',
-            });
+            const store = options.store ??
+                openCodeIndexStore({
+                    repoRoot: resolvedRoot,
+                    cacheDir: options.cacheDir,
+                    excludeDir: shared.excludeDir,
+                    noGitignore: shared.noGitignore,
+                    ignorePatterns: shared.ignorePatterns,
+                    overlayIgnorePatterns: shared.overlayIgnorePatterns,
+                    contentMode,
+                    maxFiles: options.maxCodeFiles,
+                    maxBytes: options.maxCodeBytes,
+                    onBudgetExceeded: 'truncate',
+                });
             const session = await store.getSession({
                 strategy: options.cacheStrategy ?? 'ensure-fresh',
                 signal: options.signal,
                 onProgress: scopedCodeProgress,
+                cooperative: options.cooperative,
             });
             const index = session.getIndex();
             return {
-                codeIndex: slim ? slimifyIndex(index) : index,
+                codeIndex: slim ? (yielder ? await slimifyIndexCooperative(index, yielder) : slimifyIndex(index)) : index,
                 chunkSource: index.contentMode === 'full' ? index : undefined,
             };
         }
@@ -357,7 +594,11 @@ export async function bundleWorkspace(rootDir, options = {}) {
             signal: options.signal,
         }, scopedCodeProgress);
         return {
-            codeIndex: slim ? slimifyIndex(index) : index,
+            codeIndex: slim
+                ? yielder
+                    ? await slimifyIndexCooperative(index, yielder)
+                    : slimifyIndex(index)
+                : index,
             chunkSource: index.contentMode === 'full' ? index : undefined,
         };
     };
@@ -379,11 +620,11 @@ export async function bundleWorkspace(rootDir, options = {}) {
         // post-join abortIfNeeded turns the abort into a rejection.
         let caughtAbort;
         const phaseErrors = {
-            'description': [],
-            'analysis': [],
-            'documents': [],
+            description: [],
+            analysis: [],
+            documents: [],
             'code-preview': [],
-            'code': [],
+            code: [],
         };
         const capture = (scope, err) => {
             if (isOccAbortError(err)) {
@@ -418,7 +659,7 @@ export async function bundleWorkspace(rootDir, options = {}) {
                         ...shared,
                         includeDocuments,
                         includeCode,
-                    }, (event) => onProgress?.({ ...event, scope: event.scope ?? 'workspace' }));
+                    }, event => onProgress?.({ ...event, scope: event.scope ?? 'workspace' }));
                 }
                 catch (err) {
                     capture('analysis', err);
@@ -439,7 +680,7 @@ export async function bundleWorkspace(rootDir, options = {}) {
                         includeDataFiles: options.includeDataFiles,
                         maxFiles: options.maxDocumentFiles,
                         maxReferenceFiles: options.maxReferenceFiles,
-                    }, (event) => onProgress?.({ ...event, scope: event.scope ?? 'document' }));
+                    }, event => onProgress?.({ ...event, scope: event.scope ?? 'document' }));
                 }
                 catch (err) {
                     capture('documents', err);
@@ -509,7 +750,7 @@ export async function bundleWorkspace(rootDir, options = {}) {
                     ...shared,
                     includeDocuments,
                     includeCode,
-                }, (event) => onProgress?.({ ...event, scope: event.scope ?? 'workspace' }));
+                }, event => onProgress?.({ ...event, scope: event.scope ?? 'workspace' }));
             }
             catch (err) {
                 const error = err;
@@ -526,7 +767,7 @@ export async function bundleWorkspace(rootDir, options = {}) {
                     includeDataFiles: options.includeDataFiles,
                     maxFiles: options.maxDocumentFiles,
                     maxReferenceFiles: options.maxReferenceFiles,
-                }, (event) => onProgress?.({ ...event, scope: event.scope ?? 'document' }));
+                }, event => onProgress?.({ ...event, scope: event.scope ?? 'document' }));
             }
             catch (err) {
                 const error = err;
@@ -569,7 +810,7 @@ export async function bundleWorkspace(rootDir, options = {}) {
             if (!codeChunkSource) {
                 throw new Error('Code chunks require a full-content code index.');
             }
-            codeChunks = buildCodeChunks(codeChunkSource, options, onProgress);
+            codeChunks = await buildCodeChunks(codeChunkSource, options, onProgress, yielder);
         }
         catch (err) {
             const error = err;
@@ -579,13 +820,16 @@ export async function bundleWorkspace(rootDir, options = {}) {
         reportStep(onProgress, steps[completedSteps], ++completedSteps, steps.length, startedAt);
     }
     const documentChunks = includeDocumentChunks
-        ? await buildDocumentChunks(documents, options, onProgress)
+        ? await buildDocumentChunks(documents, options, onProgress, yielder)
         : undefined;
     if (includeDocumentChunks) {
         reportStep(onProgress, steps[completedSteps], ++completedSteps, steps.length, startedAt);
     }
     const outline = buildOutline(resolvedRoot, description, documents, codeIndex);
-    const codeDocumentReferences = detectCodeDocumentReferences(codeIndex, documents, includeCodeDocumentReferences ? (options.maxCodeDocumentReferences ?? 200) : 0);
+    const referenceLimit = includeCodeDocumentReferences ? (options.maxCodeDocumentReferences ?? 200) : 0;
+    const codeDocumentReferences = yielder
+        ? await detectCodeDocumentReferencesCooperative(codeIndex, documents, referenceLimit, yielder)
+        : detectCodeDocumentReferences(codeIndex, documents, referenceLimit);
     reportStep(onProgress, steps[completedSteps], ++completedSteps, steps.length, startedAt);
     reportStep(onProgress, { phase: 'bundle', detail: 'Workspace bundle complete' }, steps.length, steps.length, startedAt);
     return {
@@ -599,7 +843,7 @@ export async function bundleWorkspace(rootDir, options = {}) {
         codeIndex,
         documentChunks,
         codeChunks,
-        corpusChunks: buildCorpusChunks(codeChunks, documentChunks, options),
+        corpusChunks: await buildCorpusChunks(codeChunks, documentChunks, options, yielder),
         outline,
         codeDocumentReferences,
         errors,