@cueloop/client 0.1.0-alpha.102 → 0.1.0-alpha.103

package/src/markdown/components/ThreadView.selection.test.tsx

@@ -98,6 +98,7 @@ function highlightedByRow(): Map<number, string> {
 
       if (backdrop || (caretCell && underlined)) marked += span.text;
     }
+
     if (marked.length > 0) rows.set(rowIndex, marked);
   });
 
@@ -121,6 +122,7 @@ function caretCells(): Array<{ row: number; column: number; text: string }> {
       if (red === CARET_RGB[0] && green === CARET_RGB[1] && blue === CARET_RGB[2]) {
         cells.push({ row, column, text: span.text });
       }
+
       column += span.width;
     }
   });
@@ -158,6 +160,7 @@ async function framesUntilHighlight(expected: string, limit = 4): Promise<number
     // one scheduler turn (the input parser and React commit), then one frame
     await new Promise((resolve) => setTimeout(resolve, 0));
     await setup.renderOnce();
+
     if (highlightedText() === expected) return frame;
   }
 

package/src/markdown/components/ThreadView.tsx

@@ -103,7 +103,9 @@ function blockStyle(block: DisplayBlock, tokens: Theme): BlockStyle {
 /** The read-only color of an inline markdown role: links accent, code and removals dim, insertions green. */
 function roleForeground(role: RunRole, baseFg: string, tokens: Theme): string {
   if (role === "link") return tokens.blue;
+
   if (role === "ins") return tokens.green;
+
   if (role === "code" || role === "del") return tokens.textDim;
 
   return baseFg;
@@ -112,7 +114,9 @@ function roleForeground(role: RunRole, baseFg: string, tokens: Theme): string {
 /** The text attributes an inline role adds over a block's base attributes. */
 function roleAttributes(role: RunRole, baseAttributes: number): number {
   if (role === "strong") return baseAttributes | BOLD;
+
   if (role === "em") return baseAttributes | ITALIC;
+
   if (role === "strike" || role === "del") return baseAttributes | CUT;
 
   return baseAttributes;
@@ -288,6 +292,7 @@ export function ThreadView({
     const block = display[index];
 
     if (!block) return 1;
+
     const usable = viewWidth > 0 ? Math.max(1, viewWidth - 6) : 40;
     const lines = Math.max(1, Math.ceil(displayText(block).length / usable));
 
@@ -378,6 +383,7 @@ export function ThreadView({
   // measurement never adds a row and shifts the blocks below it out from under a pending click
   const headingRule = (block: DisplayBlock): React.ReactNode => {
     if (block.kind !== "h1" && block.kind !== "h2") return null;
+
     const width = Math.max(1, (viewWidth > 6 ? viewWidth : 46) - 6);
 
     return (
@@ -398,6 +404,7 @@ export function ThreadView({
           {custom}
         </box>
       );
+
     const block = display[blockIndex]!;
     const { baseFg, baseAttributes, marker } = blockStyle(block, tokens);
     // list items of one list stay tight; every other block sits a blank row below its neighbour
@@ -472,8 +479,11 @@ export function ThreadView({
           cards.length > 0,
         ),
       );
+
       if (isLastLine) lineRows.push(headingRule(block));
+
       lineRows.push(...cards);
+
       if (cards.length > 0 && !isLastLine) {
         lineRows.push(<box key={`gap-${lineIndex}`} style={{ height: 1 }} />);
       }
@@ -508,14 +518,17 @@ export function ThreadView({
       for (let index = 0; index < display.length; index++) {
         nodes.push(blockNodeFor(index));
         mountedRows += estimateBlockRows(index);
+
         if (mountedRows > terminalHeight + OVERSCAN_BLOCKS) break;
       }
 
       return nodes;
     }
+
     if (firstItem.start > 0) {
       nodes.push(<box key="spacer-above" style={{ height: firstItem.start }} />);
     }
+
     for (const item of virtual.items) nodes.push(blockNodeFor(item.index));
     const below = virtual.totalSize - lastItem.end;
 

package/src/markdown/mark-runs.ts

@@ -36,6 +36,7 @@ export function runsFor(text: string, ranges: MarkRange[]): Run[] {
     const end = edges[index + 1]!;
 
     if (end <= start) continue;
+
     const covering = ranges.filter((range) => range.start <= start && end <= range.end);
 
     // the caret cell shows through a mark, so the head of a selection is visible
@@ -84,6 +85,7 @@ export function wrapLines(text: string, width: number): VisualLine[] {
           lines.push({ start: lineStart, end: lineEnd });
           lineStart = wordStart;
         }
+
         // a token wider than the line (a long identifier, a URL) breaks at the cell edge, so
         // every visual line stays one terminal row and nothing is clipped away
         while (wordEnd - lineStart > width) {
@@ -94,6 +96,7 @@ export function wrapLines(text: string, width: number): VisualLine[] {
       }
       lines.push({ start: lineStart, end: Math.max(lineEnd, lineStart) });
     }
+
     segmentStart = segmentEnd + 1;
   }
 
@@ -114,6 +117,7 @@ export function lineMarkRanges(ranges: MarkRange[], line: VisualLine): MarkRange
 /** Printable input that should reach a composer: one key, or a whole pasted run in one event. */
 export function printableSequence(key: KeyEvent): string | null {
   if (!key.sequence || key.ctrl || key.meta) return null;
+
   // reject any run carrying a control byte, so escape sequences and \r\t\b never seed a draft
   for (const character of key.sequence) if (character < " ") return null;
 

package/src/markdown/markdown-editor-syntax-style.ts

@@ -32,6 +32,7 @@ export function markdownEditorStyle(theme: Theme): MarkdownEditorStyle {
   const cached = markdownEditorStyleCache.get(theme);
 
   if (cached) return cached;
+
   const groupStyles = markdownGroupStyles(theme);
   const style = SyntaxStyle.fromStyles(groupStyles);
   const styleIds = new Map<MarkdownHighlightGroup, number>();

package/src/markdown/markdown-grid.ts

@@ -52,7 +52,9 @@ function splitTableRow(line: string): string[] {
     }
   }
   parts.push(cell);
+
   if (parts.length > 1 && parts[0] === "") parts.shift();
+
   if (parts.length > 1 && parts[parts.length - 1] === "") parts.pop();
 
   return parts.map((part) => part.trim());
@@ -78,6 +80,7 @@ function pad(text: string, width: number, align: ColumnAlign): string {
   const slack = Math.max(0, width - text.length);
 
   if (align === "right") return " ".repeat(slack) + text;
+
   if (align === "center") {
     const left = Math.floor(slack / 2);
 
@@ -132,6 +135,7 @@ export function parseFrontmatterRows(text: string): FrontmatterRow[] {
 
   for (const line of text.split("\n")) {
     if (line.trim() === "") continue;
+
     const match = /^([^:\s][^:]*):\s?(.*)$/.exec(line);
 
     if (match) {
@@ -163,6 +167,7 @@ function wrapCell(value: string, width: number): string[] {
  */
 export function layoutFrontmatterGrid(rows: FrontmatterRow[], maxWidth: number): GridLine[] {
   if (rows.length === 0) return [];
+
   const keyWidth = Math.max(3, ...rows.map((row) => row.key.length));
   // size the value column to its content, capped at the width left after the key column and borders,
   // so a short frontmatter table stays compact and a long value wraps instead of overflowing
@@ -183,6 +188,7 @@ export function layoutFrontmatterGrid(rows: FrontmatterRow[], maxWidth: number):
 
   rows.forEach((row, rowIndex) => {
     if (rowIndex > 0) lines.push(rule("├", "┼", "┤"));
+
     const valueLines = wrapCell(row.value, valueWidth);
 
     valueLines.forEach((valueLine, valueIndex) => {

package/src/markdown/markdown-highlight.ts

@@ -50,6 +50,7 @@ function scanInlineTokens(text: string, base: number, into: MarkdownHighlightRan
       into.push({ start, end, group: "code" });
       continue;
     }
+
     // a link colors its brackets and href; the [] label stays plain unless it is an @-scope, matching how a
     // markdown source view paints links
     const closeBracket = token.indexOf("]");

package/src/markdown/thread-code-syntax.ts

@@ -14,6 +14,7 @@ export async function highlightThreadCodeBlocks(
 ): Promise<Map<number, SyntaxSpan[]>> {
   const jobs = display.flatMap((block, blockIndex) => {
     if (block.kind !== "code") return [];
+
     const filetype = filetypeFor(block.work?.lang ?? block.base?.lang);
 
     return filetype ? [{ blockIndex, filetype, source: renderedText(block) }] : [];
@@ -21,6 +22,7 @@ export async function highlightThreadCodeBlocks(
   const byBlock = new Map<number, SyntaxSpan[]>();
 
   if (jobs.length === 0) return byBlock;
+
   const client = getTreeSitterClient();
 
   await client.initialize();
@@ -28,6 +30,7 @@ export async function highlightThreadCodeBlocks(
     const result = await client.highlightOnce(job.source, job.filetype);
 
     if (!result.highlights) continue;
+
     const spans: SyntaxSpan[] = [];
     let offset = 0;
     const lines = job.source.split("\n");

package/src/markdown/view-plan.ts

@@ -61,6 +61,7 @@ function singleRangeTextChanges(
   newText: string,
 ): ReturnType<typeof wordLevelChanges> | null {
   if (oldText === newText || oldText.length === newText.length) return null;
+
   let prefixLength = 0;
 
   while (
@@ -77,7 +78,9 @@ function singleRangeTextChanges(
     oldText[oldText.length - 1 - suffixLength] === newText[newText.length - 1 - suffixLength]
   )
     suffixLength++;
+
   if (prefixLength + suffixLength !== shorterLength) return null;
+
   const commonPrefix = oldText.slice(0, prefixLength);
   const commonSuffix = oldText.slice(oldText.length - suffixLength);
   const changed =
@@ -101,8 +104,11 @@ function singleRangeTextChanges(
 /** Word-overlap similarity gate: an unrelated cut + insert must not merge. */
 function similar(baseBlock: Block, workBlock: Block, expectedText?: string): boolean {
   if (baseBlock.kind !== workBlock.kind) return false;
+
   if (expectedText === workBlock.text) return true;
+
   if (singleRangeTextChanges(baseBlock.text, workBlock.text)) return true;
+
   const words = (text: string) => new Set(text.toLowerCase().split(/\s+/).filter(Boolean));
   const baseWords = words(baseBlock.text);
   const workWords = words(workBlock.text);
@@ -132,6 +138,7 @@ export function buildDisplay(
     const segments = sourceSegments[blockIndex];
 
     if (!segments?.length) return;
+
     const sourceStart = segments[0]!.sourceStart;
     const last = segments.at(-1)!;
     const sourceEnd = last.sourceStart + last.textEnd - last.textStart;
@@ -143,6 +150,7 @@ export function buildDisplay(
       const cut = exactCuts[index]!;
 
       if (cut.start >= sourceEnd) break;
+
       const start = blockTextBoundary(segments, block.text.length, cut.start);
       const end = blockTextBoundary(segments, block.text.length, cut.end);
 
@@ -153,6 +161,7 @@ export function buildDisplay(
     };
 
     if (ranges.length > 0) data.textCutRanges = ranges;
+
     cutData.set(block, data);
   });
   const blockCutData = (block: Block) => cutData.get(block) ?? {};
@@ -160,6 +169,7 @@ export function buildDisplay(
     const data = blockCutData(block);
 
     if (!data.textCutRanges) return undefined;
+
     let text = block.text;
 
     for (let index = data.textCutRanges.length - 1; index >= 0; index--) {
@@ -178,6 +188,7 @@ export function buildDisplay(
       if (!data.textCutRanges) {
         return { type: "same", kind: base.kind, base, work: base, ...data };
       }
+
       const text = expectedBlockText(base)!;
 
       return {
@@ -207,6 +218,7 @@ export function buildDisplay(
 
     return display;
   }
+
   const workBlocks = parseBlocks(workingContent);
   const signature = (block: Block) => block.kind + "\0" + block.text;
   const ops = lcsDiff(
@@ -225,6 +237,7 @@ export function buildDisplay(
       opIndex++;
       continue;
     }
+
     const deletedBlocks: Block[] = [];
     const addedBlocks: Block[] = [];
 
@@ -233,6 +246,7 @@ export function buildDisplay(
 
       if (changeOp.kind === "del") deletedBlocks.push(changeOp.oldValue!);
       else addedBlocks.push(changeOp.newValue!);
+
       opIndex++;
     }
     let deletedIndex = 0;
@@ -309,6 +323,7 @@ function blockTextBoundary(
     const sourceEnd = segment.sourceStart + segment.textEnd - segment.textStart;
 
     if (sourceOffset < segment.sourceStart) return segment.textStart;
+
     if (sourceOffset <= sourceEnd) return segment.textStart + sourceOffset - segment.sourceStart;
   }
 
@@ -377,13 +392,16 @@ export function marksByDisplay(
   for (const annotation of annotations) {
     // an addressed annotation keeps its record but paints no highlight
     if (isAddressed(annotation)) continue;
+
     const resolved = resolveAnchor(annotation.anchor, workBlocks);
 
     if (!resolved) continue;
+
     const startEntry = workEntries[resolved.blockIndex];
     const endEntry = workEntries[resolved.endBlockIndex];
 
     if (!startEntry || !endEntry) continue;
+
     // resolveAnchor works in the block's work text; the surface paints and hit-tests in rendered
     // text (markers concealed), so map the span onto the visible characters it covers
     const renderedStart = renderedOffsetAtOrAfter(
@@ -396,6 +414,7 @@ export function marksByDisplay(
     );
 
     if (renderedStart === null || renderedEndInclusive === null) continue;
+
     const span: TextSpan = {
       start: { blockIndex: startEntry.displayIndex, char: renderedStart },
       end: { blockIndex: endEntry.displayIndex, char: renderedEndInclusive + 1 },
@@ -407,6 +426,7 @@ export function marksByDisplay(
       const range = spanRangeInBlock(span, entry.displayIndex, renderedText(entry.block).length);
 
       if (!range) continue;
+
       const marks = marksByIndex.get(entry.displayIndex) ?? [];
 
       marks.push({
@@ -425,6 +445,7 @@ export function marksByDisplay(
 
 function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null {
   if (!block.base || !block.work || !block.textCutRanges) return null;
+
   const localCuts = block.textCutRanges;
   const expected = localCuts.reduceRight(
     (text, cut) => text.slice(0, cut.start) + text.slice(cut.end),
@@ -432,6 +453,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
   );
 
   if (expected !== block.work.text) return null;
+
   const sourceRuns = literal
     ? [{ text: block.base.text, role: "plain" as const, start: 0 }]
     : inlineStyleRuns(block.base.text, 0);
@@ -441,6 +463,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
 
   for (const sourceRun of sourceRuns) {
     if (sourceRun.start === null) continue;
+
     const runStart = sourceRun.start;
     const runEnd = runStart + sourceRun.text.length;
     let position = runStart;
@@ -461,6 +484,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
         });
         break;
       }
+
       if (position < cut.start) {
         const commonEnd = Math.min(runEnd, cut.start);
 
@@ -473,6 +497,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
         position = commonEnd;
         continue;
       }
+
       const removedEnd = Math.min(runEnd, cut.end);
 
       runs.push({
@@ -482,6 +507,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
         baseStart: position,
       });
       position = removedEnd;
+
       if (position === cut.end) {
         deletedBefore += cut.end - cut.start;
         cutIndex++;
@@ -518,6 +544,7 @@ export function blockRuns(block: DisplayBlock, markup: boolean): StyleRun[] {
         runs.push({ text: change.text, role: "del", start: null });
         continue;
       }
+
       // A code/rule block stays literal; prose segments inline-tokenize so their
       // markers conceal while their work offsets stay intact. Added text keeps
       // the green diff role (it wins over emphasis); context text shows emphasis.
@@ -533,6 +560,7 @@ export function blockRuns(block: DisplayBlock, markup: boolean): StyleRun[] {
 
     return runs;
   }
+
   const text = displayText(block);
 
   // Prose carries inline markup; code fences and rules are literal. Concealed
@@ -550,6 +578,7 @@ export function blockRuns(block: DisplayBlock, markup: boolean): StyleRun[] {
  *  document could otherwise splice into the terminal escape stream. */
 export function safeLinkHref(href: string | undefined): string | undefined {
   if (href === undefined) return undefined;
+
   if (!/^(https?:|mailto:)/i.test(href)) return undefined;
 
   return /^[\x21-\x7e]+$/.test(href) ? href : undefined;
@@ -565,6 +594,7 @@ export function inlineStyleRuns(text: string, base: number): StyleRun[] {
 
   for (const run of inlineRuns(text)) {
     if (run.role === "marker" || run.start === null) continue;
+
     const styleRun: StyleRun = {
       text: run.text,
       role: run.role === "text" ? "plain" : run.role,
@@ -572,6 +602,7 @@ export function inlineStyleRuns(text: string, base: number): StyleRun[] {
     };
 
     if (run.href !== undefined) styleRun.href = run.href;
+
     runs.push(styleRun);
   }
 
@@ -595,6 +626,7 @@ export function renderedStyleRuns(block: DisplayBlock): RenderedRun[] {
     const positioned: RenderedRun = { text: run.text, role: run.role, start: rendered };
 
     if (run.href !== undefined) positioned.href = run.href;
+
     runs.push(positioned);
     rendered += run.text.length;
   }
@@ -619,6 +651,7 @@ function addSyntaxBoundaries(
 ): void {
   for (const span of syntaxSpans) {
     if (span.start > line.start && span.start < line.end) cuts.add(span.start);
+
     if (span.end > line.start && span.end < line.end) cuts.add(span.end);
   }
 }
@@ -647,6 +680,7 @@ export function styledRunsFor(
 
   for (const run of roleRuns) {
     if (run.start > line.start && run.start < line.end) cuts.add(run.start);
+
     const runEnd = run.start + run.text.length;
 
     if (runEnd > line.start && runEnd < line.end) cuts.add(runEnd);
@@ -669,6 +703,7 @@ export function styledRunsFor(
     const end = edges[index + 1]!;
 
     if (end <= start) continue;
+
     const roleRun = roleRuns.find(
       (candidate) => candidate.start <= start && start < candidate.start + candidate.text.length,
     );
@@ -681,9 +716,11 @@ export function styledRunsFor(
     };
 
     if (roleRun?.href !== undefined) styled.href = roleRun.href;
+
     const syntaxGroup = syntaxGroupForRun(syntaxSpans, start, end);
 
     if (syntaxGroup) styled.syntaxGroup = syntaxGroup;
+
     runs.push(styled);
   }
 
@@ -693,6 +730,7 @@ export function styledRunsFor(
 /** Split runs at mark boundaries; marks only bind to runs with offsets. */
 export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
   if (!marks.length) return runs;
+
   const splitRuns: StyleRun[] = [];
 
   for (const run of runs) {
@@ -700,6 +738,7 @@ export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
       splitRuns.push(run);
       continue;
     }
+
     const bounds = new Set<number>([0, run.text.length]);
 
     for (const mark of marks) {
@@ -719,6 +758,7 @@ export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
       const sliceEnd = boundaries[boundaryIndex + 1]!;
 
       if (sliceStart >= sliceEnd) continue;
+
       const absoluteStart = runStart + sliceStart;
       const mark = marks.find(
         (candidate) => candidate.start <= absoluteStart && runStart + sliceEnd <= candidate.end,
@@ -751,6 +791,7 @@ export function renderedOffsetFor(runs: StyleRun[], workOffset: number): number
     if (run.start !== null && workOffset >= run.start && workOffset < run.start + run.text.length) {
       return rendered + (workOffset - run.start);
     }
+
     rendered += run.text.length;
   }
 
@@ -770,6 +811,7 @@ export function renderedOffsetAtOrAfter(runs: StyleRun[], workOffset: number): n
     if (run.start !== null && run.start + run.text.length > workOffset) {
       return rendered + Math.max(0, workOffset - run.start);
     }
+
     rendered += run.text.length;
   }
 
@@ -788,6 +830,7 @@ export function renderedOffsetAtOrBefore(runs: StyleRun[], workOffset: number):
     if (run.start !== null && run.start <= workOffset) {
       best = rendered + Math.min(workOffset - run.start, run.text.length - 1);
     }
+
     rendered += run.text.length;
   }
 
@@ -812,11 +855,14 @@ export function workRangeForRendered(
     const runRenderedEnd = rendered + run.text.length;
 
     rendered = runRenderedEnd;
+
     if (run.start === null) continue;
+
     const overlapStart = Math.max(renderedStart, runRenderedStart);
     const overlapEnd = Math.min(renderedEnd, runRenderedEnd);
 
     if (overlapEnd <= overlapStart) continue;
+
     const workStart = run.start + (overlapStart - runRenderedStart);
     const workEnd = run.start + (overlapEnd - runRenderedStart);
 
@@ -844,11 +890,14 @@ export function baseRangeForRendered(
     const runRenderedEnd = rendered + run.text.length;
 
     rendered = runRenderedEnd;
+
     if (run.baseStart === undefined) continue;
+
     const overlapStart = Math.max(renderedStart, runRenderedStart);
     const overlapEnd = Math.min(renderedEnd, runRenderedEnd);
 
     if (overlapEnd <= overlapStart) continue;
+
     const baseStart = run.baseStart + overlapStart - runRenderedStart;
     const baseEnd = run.baseStart + overlapEnd - runRenderedStart;
 
@@ -883,6 +932,7 @@ export function renderedSpanToWork(
 
     return range ?? { start: renderedStart, end: renderedEnd };
   }
+
   const startRuns = blockRuns(startBlock, true);
   const startRange = workRangeForRendered(
     startRuns,
@@ -952,6 +1002,7 @@ export function spanFromRange(
   const wordIndex = words.findIndex((word) => word[1] > start);
 
   if (wordIndex === -1) return null;
+
   let wordEnd = wordIndex;
 
   for (let index = wordIndex; index < words.length && words[index]![0] < end; index++) {
@@ -989,6 +1040,7 @@ export function spanKey(span: SpanState, key: string, text: string): SpanState {
     nextSpan.wordEnd = width;
     nextSpan.wordIndex = 0;
   } else return span;
+
   nextSpan.start = words[nextSpan.wordIndex]![0];
   nextSpan.end = words[nextSpan.wordEnd]![1];
 

package/src/performance/perf-report.ts

@@ -14,5 +14,6 @@ export function reportPerfMarks(scope: string): void {
   if (marks.length === 0) return;
 
   if (process.env.CUELOOP_PERF === "1") process.stderr.write(formatPerfBlock(scope, marks));
+
   void postOtlpTrace(PERF_SERVICE_NAME, phaseMarksToSpans(scope, marks));
 }

package/src/performance/perf-timings.ts

@@ -17,6 +17,7 @@ function perfInstrumentationEnabled(): boolean {
 /** Record the elapsed ms since the previous mark (or process start) under `label`. */
 export function perfMark(label: string): void {
   if (!perfInstrumentationEnabled()) return;
+
   const now = performance.now();
 
   phaseMarks.push({ label, elapsedMs: now - (lastMarkAt ?? 0) });