@jini-ai/chat 0.6.6 → 0.6.10

package/dist/core/util/parser.js

@@ -11,6 +11,8 @@ import { computeSkipRanges, FENCE_OPEN_RE, isRealArtifactOpenAt, rangeContains }
 import { parseQuotedAttrs } from './markup-attributes.js';
 const OPEN_PREFIX = '<artifact';
 const CLOSE_TAG = '</artifact>';
+const NO_OPEN = { kind: 'none' };
+const SKIP = { kind: 'skip' };
 // Scan the buffer for `<artifact …>` while skipping any positions that a
 // Markdown renderer would render as a fenced code block or inline code span
 // — see markdown-context.ts for the shared classification used by both this
@@ -23,107 +25,100 @@ const CLOSE_TAG = '</artifact>';
 //   * Unmatched opening backtick after the last \n → hold back from it; a
 //     future chunk may turn it into an inline code span.
 function findOpenTag(buffer) {
-    const len = buffer.length;
     const { ranges, unclosedFenceStart } = computeSkipRanges({ buffer: buffer });
+    const ctx = { buffer, ranges };
     // Pass 1: scan for the earliest *complete* real `<artifact …>` open outside
     // any skip range, before any hold-back decision — otherwise a stray
     // backtick or fence-opener prefix on a tail line would suppress an
     // already self-contained artifact earlier in the buffer.
-    let earliestPartialOpen = -1;
-    let from = 0;
-    while (from < len) {
-        const idx = buffer.indexOf(OPEN_PREFIX, from);
-        if (idx === -1)
-            break;
-        if (rangeContains({ ranges: ranges, p: idx })) {
-            from = idx + OPEN_PREFIX.length;
-            continue;
-        }
-        if (unclosedFenceStart !== null && idx >= unclosedFenceStart) {
-            // Anything past an unclosed fence opener is inside a code block that
-            // will close in a later chunk; treat as skip range, not a real tag.
-            break;
-        }
-        const after = idx + OPEN_PREFIX.length;
-        const next = buffer.charAt(after);
-        if (next === '') {
-            // `<artifact` at very end of buffer — could become real with the next
-            // chunk. Remember the earliest one and keep looking for a complete tag.
-            if (earliestPartialOpen === -1)
-                earliestPartialOpen = idx;
-            break;
-        }
-        if (!isRealArtifactOpenAt({ content: buffer, idx: idx })) {
-            from = after; // e.g. "<artifactual" — not a real open, keep scanning
-            continue;
-        }
-        let j = after;
-        let quote = null;
-        while (j < len) {
-            const c = buffer.charAt(j);
-            if (quote !== null) {
-                if (c === quote)
-                    quote = null;
-            }
-            else if (c === '"' || c === "'") {
-                quote = c;
-            }
-            else if (c === '>') {
-                return { kind: 'complete', start: idx, end: j + 1, attrs: buffer.slice(after, j) };
-            }
-            j++;
-        }
-        // Ran out of buffer before the closing `>` arrived — an open tag mid-stream.
-        if (earliestPartialOpen === -1)
-            earliestPartialOpen = idx;
-        break;
-    }
+    const open = scanForOpen(ctx, { unclosedFenceStart });
+    if (open.kind === 'complete')
+        return open;
     // Pass 2: no complete open found. Decide whether to hold back, and if so,
     // from which position. Earliest hold-back wins so the text-flush boundary
     // never crosses something that might still resolve into a tag/fence/span.
-    let holdback = -1;
-    const note = (pos) => {
-        if (pos !== null && pos !== -1 && (holdback === -1 || pos < holdback))
-            holdback = pos;
-    };
-    note(earliestPartialOpen);
-    note(unclosedFenceStart);
-    const lastNl = buffer.lastIndexOf('\n');
-    if (lastNl < len - 1) {
-        const tailLineStart = lastNl + 1;
-        const tail = buffer.slice(tailLineStart);
-        if (FENCE_OPEN_RE.test(tail) || /^`{1,2}$/.test(tail)) {
-            note(tailLineStart);
+    const holdbacks = [
+        open.kind === 'partial' ? open.start : -1,
+        unclosedFenceStart ?? -1,
+        tailFenceHoldback(ctx),
+        unmatchedBacktickHoldback(ctx),
+        tailPrefixHoldback(ctx),
+    ].filter((pos) => pos !== -1);
+    if (holdbacks.length === 0)
+        return NO_OPEN;
+    return { kind: 'partial', start: Math.min(...holdbacks) };
+}
+function scanForOpen(ctx, { unclosedFenceStart }) {
+    let idx = ctx.buffer.indexOf(OPEN_PREFIX);
+    while (idx !== -1) {
+        const found = classifyOpenAt(ctx, { idx, unclosedFenceStart });
+        if (found.kind !== 'skip')
+            return found;
+        idx = ctx.buffer.indexOf(OPEN_PREFIX, idx + OPEN_PREFIX.length);
+    }
+    return NO_OPEN;
+}
+function classifyOpenAt({ buffer, ranges }, { idx, unclosedFenceStart }) {
+    if (rangeContains({ ranges: ranges, p: idx }))
+        return SKIP;
+    // Anything past an unclosed fence opener is inside a code block that
+    // will close in a later chunk; treat as skip range, not a real tag.
+    if (unclosedFenceStart !== null && idx >= unclosedFenceStart)
+        return NO_OPEN;
+    const after = idx + OPEN_PREFIX.length;
+    // `<artifact` at very end of buffer — could become real with the next
+    // chunk. Remember the earliest one and keep looking for a complete tag.
+    if (after === buffer.length)
+        return { kind: 'partial', start: idx };
+    if (!isRealArtifactOpenAt({ content: buffer, idx: idx }))
+        return SKIP; // e.g. "<artifactual" — not a real open, keep scanning
+    const close = findTagEnd({ buffer, from: after });
+    // Ran out of buffer before the closing `>` arrived — an open tag mid-stream.
+    if (close === -1)
+        return { kind: 'partial', start: idx };
+    return { kind: 'complete', start: idx, end: close + 1, attrs: buffer.slice(after, close) };
+}
+/** Index of the open tag's closing `>`, ignoring any `>` inside a quoted attribute value; -1 if not yet arrived. */
+function findTagEnd({ buffer, from }) {
+    let quote = null;
+    for (let j = from; j < buffer.length; j++) {
+        const c = buffer.charAt(j);
+        if (quote !== null) {
+            if (c === quote)
+                quote = null;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === '>') {
+            return j;
         }
     }
+    return -1;
+}
+/** Start of an unterminated tail line that could still resolve into a fence delimiter; -1 otherwise. */
+function tailFenceHoldback({ buffer }) {
+    const tailLineStart = buffer.lastIndexOf('\n') + 1;
+    const tail = buffer.slice(tailLineStart);
+    return FENCE_OPEN_RE.test(tail) || /^`{1,2}$/.test(tail) ? tailLineStart : -1;
+}
+/** Position of an unmatched opening backtick after the last `\n` (outside skip ranges); -1 otherwise. */
+function unmatchedBacktickHoldback({ buffer, ranges }) {
     let firstUnmatched = -1;
-    let parity = 0;
-    for (let k = lastNl + 1; k < len; k++) {
-        if (buffer.charAt(k) !== '`')
+    for (let k = buffer.lastIndexOf('\n') + 1; k < buffer.length; k++) {
+        if (buffer.charAt(k) !== '`' || rangeContains({ ranges: ranges, p: k }))
             continue;
-        if (rangeContains({ ranges: ranges, p: k }))
-            continue;
-        if (parity === 0) {
-            firstUnmatched = k;
-            parity = 1;
-        }
-        else {
-            firstUnmatched = -1;
-            parity = 0;
-        }
+        firstUnmatched = firstUnmatched === -1 ? k : -1;
     }
-    note(firstUnmatched);
-    // Strict prefix at the tail (e.g. "<art") — hold back.
+    return firstUnmatched;
+}
+// Strict prefix at the tail (e.g. "<art") — hold back.
+function tailPrefixHoldback({ buffer, ranges }) {
     const tailLt = buffer.lastIndexOf('<');
-    if (tailLt !== -1 && !rangeContains({ ranges: ranges, p: tailLt })) {
-        const slice = buffer.slice(tailLt);
-        if (OPEN_PREFIX.startsWith(slice) && slice.length < OPEN_PREFIX.length) {
-            note(tailLt);
-        }
-    }
-    if (holdback !== -1)
-        return { kind: 'partial', start: holdback };
-    return { kind: 'none' };
+    if (tailLt === -1 || rangeContains({ ranges: ranges, p: tailLt }))
+        return -1;
+    const slice = buffer.slice(tailLt);
+    return OPEN_PREFIX.startsWith(slice) && slice.length < OPEN_PREFIX.length ? tailLt : -1;
 }
 /**
  * Create a fresh streaming artifact parser. Call `feed({ delta })` for each
@@ -146,64 +141,61 @@ export function createArtifactParser(_requiredArgs) {
     };
     function* feed({ delta }) {
         state.buffer += delta;
-        while (state.buffer.length > 0) {
-            if (!state.inside) {
-                const open = findOpenTag(state.buffer);
-                if (open.kind === 'none') {
-                    yield { type: 'text', delta: state.buffer };
-                    state.buffer = '';
-                    return;
-                }
-                if (open.kind === 'partial') {
-                    if (open.start > 0) {
-                        yield { type: 'text', delta: state.buffer.slice(0, open.start) };
-                        state.buffer = state.buffer.slice(open.start);
-                    }
-                    return;
-                }
-                if (open.start > 0) {
-                    yield { type: 'text', delta: state.buffer.slice(0, open.start) };
-                }
-                const attrs = parseQuotedAttrs({ raw: open.attrs });
-                state.inside = true;
-                state.identifier = attrs['identifier'] ?? '';
-                state.artifactType = attrs['type'] ?? '';
-                state.title = attrs['title'] ?? '';
-                state.content = '';
-                state.buffer = state.buffer.slice(open.end);
-                yield {
-                    type: 'artifact:start',
-                    identifier: state.identifier,
-                    artifactType: state.artifactType,
-                    title: state.title,
-                };
-                continue;
-            }
-            const closeIdx = state.buffer.indexOf(CLOSE_TAG);
-            if (closeIdx === -1) {
-                // Hold back enough bytes to detect a partial close tag at the tail.
-                const flushUpTo = state.buffer.length - (CLOSE_TAG.length - 1);
-                if (flushUpTo > 0) {
-                    const chunk = state.buffer.slice(0, flushUpTo);
-                    state.content += chunk;
-                    state.buffer = state.buffer.slice(flushUpTo);
-                    yield { type: 'artifact:chunk', identifier: state.identifier, delta: chunk };
-                }
-                return;
-            }
-            const finalChunk = state.buffer.slice(0, closeIdx);
-            if (finalChunk.length > 0) {
-                state.content += finalChunk;
-                yield { type: 'artifact:chunk', identifier: state.identifier, delta: finalChunk };
-            }
-            yield { type: 'artifact:end', identifier: state.identifier, fullContent: state.content };
-            state.buffer = state.buffer.slice(closeIdx + CLOSE_TAG.length);
-            state.inside = false;
-            state.identifier = '';
-            state.artifactType = '';
-            state.title = '';
-            state.content = '';
+        let progressed = true;
+        while (progressed && state.buffer.length > 0) {
+            progressed = state.inside ? yield* drainInside() : yield* drainOutside();
+        }
+    }
+    /** Emit text up to the next open tag; `true` when an artifact was opened and draining should continue. */
+    function* drainOutside() {
+        const open = findOpenTag(state.buffer);
+        const textEnd = open.kind === 'none' ? state.buffer.length : open.start;
+        if (textEnd > 0) {
+            yield { type: 'text', delta: state.buffer.slice(0, textEnd) };
+            state.buffer = state.buffer.slice(textEnd);
+        }
+        if (open.kind !== 'complete')
+            return false;
+        const attrs = parseQuotedAttrs({ raw: open.attrs });
+        Object.assign(state, {
+            inside: true,
+            identifier: attrs['identifier'] ?? '',
+            artifactType: attrs['type'] ?? '',
+            title: attrs['title'] ?? '',
+            content: '',
+            buffer: state.buffer.slice(open.end - open.start),
+        });
+        yield {
+            type: 'artifact:start',
+            identifier: state.identifier,
+            artifactType: state.artifactType,
+            title: state.title,
+        };
+        return true;
+    }
+    /** Emit body up to the close tag; `true` when the artifact closed and draining should continue. */
+    function* drainInside() {
+        const closeIdx = state.buffer.indexOf(CLOSE_TAG);
+        // Hold back enough bytes to detect a partial close tag at the tail.
+        const chunkEnd = closeIdx === -1 ? state.buffer.length - (CLOSE_TAG.length - 1) : closeIdx;
+        if (chunkEnd > 0) {
+            const chunk = state.buffer.slice(0, chunkEnd);
+            state.content += chunk;
+            state.buffer = state.buffer.slice(chunkEnd);
+            yield { type: 'artifact:chunk', identifier: state.identifier, delta: chunk };
         }
+        if (closeIdx === -1)
+            return false;
+        yield { type: 'artifact:end', identifier: state.identifier, fullContent: state.content };
+        Object.assign(state, {
+            inside: false,
+            identifier: '',
+            artifactType: '',
+            title: '',
+            content: '',
+            buffer: state.buffer.slice(CLOSE_TAG.length),
+        });
+        return true;
     }
     function* flush(_requiredArgs) {
         if (state.inside) {

package/dist/core/util/pointer.js

@@ -13,29 +13,29 @@ const HTML_TAG_RE = /<[^>]+>/g;
  * @complexity O(n + m) in `content.length` plus `projectFiles.length`.
  */
 export function resolveHtmlPointerArtifactTarget(input) {
-    const pointerText = visiblePointerText(input.content);
-    if (!pointerText || utf8ByteLength(pointerText) > MAX_POINTER_TEXT_BYTES) {
+    const target = extractPointerTarget(input.content);
+    if (target === null || target === input.candidateFileName || !isSafeHtmlTarget(target))
         return null;
-    }
-    const match = POINTER_TARGET_RE.exec(pointerText);
-    if (!match)
+    return resolveAgainstProjectFiles({ target, candidateFileName: input.candidateFileName, projectFiles: input.projectFiles });
+}
+/** The normalized file name a bare short pointer reply names, or `null` when `content` isn't one. */
+function extractPointerTarget(content) {
+    const pointerText = visiblePointerText(content);
+    if (!pointerText || utf8ByteLength(pointerText) > MAX_POINTER_TEXT_BYTES)
         return null;
+    const match = POINTER_TARGET_RE.exec(pointerText);
     // The target group is a mandatory (non-optional) part of the pattern, not
     // inside an alternation, so it's always defined when `match` is non-null;
     // the assertion just satisfies `noUncheckedIndexedAccess`.
-    const target = normalizeTarget(match[1]);
-    if (!target || target === input.candidateFileName || !isSafeHtmlTarget(target)) {
-        return null;
-    }
-    const projectFileNames = input.projectFiles.map((file) => file.path || file.name).filter((name) => name.toLowerCase().endsWith('.html') || name.toLowerCase().endsWith('.htm'));
+    return match ? normalizeTarget(match[1]) : null;
+}
+/** A full-path match wins; otherwise exactly one basename match that isn't the candidate itself. */
+function resolveAgainstProjectFiles({ target, candidateFileName, projectFiles }) {
+    const projectFileNames = projectFiles.map((file) => file.path || file.name).filter((name) => /\.html?$/i.test(name));
     if (projectFileNames.includes(target))
         return target;
-    const basenameMatches = projectFileNames.filter((name) => basename(name) === target);
-    const [basenameMatch] = basenameMatches;
-    if (basenameMatches.length === 1 && basenameMatch && basenameMatch !== input.candidateFileName) {
-        return basenameMatch;
-    }
-    return null;
+    const [only, ...others] = projectFileNames.filter((name) => basename(name) === target);
+    return only !== undefined && others.length === 0 && only !== candidateFileName ? only : null;
 }
 function visiblePointerText(content) {
     const stripped = content

package/dist/core/util/strip.js

@@ -45,6 +45,29 @@ function findRealOpen(content, fromIndex, ranges) {
         return idx;
     }
 }
+// For complete (non-streaming) content, an unclosed fence renders as a code
+// block extending to end of input — the stripper mirrors that, otherwise a
+// literal `<artifact …>` tucked into a trailing code example (no trailing
+// newline) gets treated as a real protocol tag and eaten.
+function completeContentSkipRanges({ content }) {
+    const { ranges, unclosedFenceStart } = computeSkipRanges({ buffer: content });
+    return unclosedFenceStart !== null ? [...ranges, [unclosedFenceStart, content.length]] : ranges;
+}
+/**
+ * The first complete real `<artifact …>…</artifact>` block at or after
+ * `fromIndex`, or `null` when there is no real open, the open tag never
+ * terminates with `>`, or no real close follows it.
+ */
+function findCompleteArtifactBlock({ content, ranges }, { fromIndex = 0 } = {}) {
+    const open = findRealOpen(content, fromIndex, ranges);
+    if (open === -1)
+        return null;
+    const openEnd = content.indexOf('>', open);
+    if (openEnd === -1)
+        return null;
+    const close = findUnskipped(content, CLOSE, openEnd, ranges);
+    return close === -1 ? null : { open, openEnd, close };
+}
 /**
  * Remove the first real `<artifact …>…</artifact>` block from `content`.
  *
@@ -62,22 +85,10 @@ function findRealOpen(content, fromIndex, ranges) {
  *   pair of linear scans for the open/close tags.
  */
 export function stripArtifact({ content }) {
-    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges({ buffer: content });
-    // For complete (non-streaming) content, an unclosed fence renders as a code
-    // block extending to end of input — the stripper mirrors that, otherwise a
-    // literal `<artifact …>` tucked into a trailing code example (no trailing
-    // newline) gets treated as a real protocol tag and eaten.
-    const ranges = unclosedFenceStart !== null ? [...baseRanges, [unclosedFenceStart, content.length]] : baseRanges;
-    const open = findRealOpen(content, 0, ranges);
-    if (open === -1)
+    const block = findCompleteArtifactBlock({ content, ranges: completeContentSkipRanges({ content }) });
+    if (!block)
         return content;
-    const closeTag = content.indexOf('>', open);
-    if (closeTag === -1)
-        return content;
-    const end = findUnskipped(content, CLOSE, closeTag, ranges);
-    if (end === -1)
-        return content;
-    return (content.slice(0, open) + content.slice(end + CLOSE.length)).trim();
+    return (content.slice(0, block.open) + content.slice(block.close + CLOSE.length)).trim();
 }
 function findSingleRecoverableHtmlFence(content) {
     HTML_FENCE_RE.lastIndex = 0;
@@ -95,31 +106,24 @@ function findSingleRecoverableHtmlFence(content) {
     return count === 1 ? recovered : null;
 }
 function findRecoverablePrecedingHtmlArtifact(sourceText) {
-    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges({ buffer: sourceText });
-    const ranges = unclosedFenceStart !== null ? [...baseRanges, [unclosedFenceStart, sourceText.length]] : baseRanges;
+    const ranges = completeContentSkipRanges({ content: sourceText });
     let from = 0;
     // `findRealOpen` already returns -1 once `from` runs past `sourceText.length`
     // (it inherits the same `indexOf`-based bound safety), so this loop also
     // always exits through an inner return — no trailing fallback needed.
     for (;;) {
-        const open = findRealOpen(sourceText, from, ranges);
-        if (open === -1)
-            return null;
-        const closeTag = sourceText.indexOf('>', open);
-        if (closeTag === -1)
-            return null;
-        const end = findUnskipped(sourceText, CLOSE, closeTag, ranges);
-        if (end === -1)
+        const block = findCompleteArtifactBlock({ content: sourceText, ranges }, { fromIndex: from });
+        if (!block)
             return null;
-        const attrs = parseQuotedAttrs({ raw: sourceText.slice(open, closeTag) });
+        const attrs = parseQuotedAttrs({ raw: sourceText.slice(block.open, block.openEnd) });
         const recovered = recoverHtmlArtifactFromPrecedingDocument({
-            artifactHtml: sourceText.slice(closeTag + 1, end),
+            artifactHtml: sourceText.slice(block.openEnd + 1, block.close),
             identifier: attrs['identifier'],
             sourceText,
         });
         if (recovered)
             return recovered;
-        from = end + CLOSE.length;
+        from = block.close + CLOSE.length;
     }
 }
 function stripRecoverablePrecedingHtml(content, sourceText) {
@@ -156,21 +160,20 @@ export function stripRecoveredHtmlFallbackForDisplay({ content }, { sourceText =
         return content;
     return `${content.slice(0, fence.start)}${content.slice(fence.end)}`.trim();
 }
+// Checked in order; the first rule whose identifier suffix, exact type, or type substring matches wins.
+const EXTENSION_RULES = [
+    { ext: '.tsx', typeIncludes: ['tsx'] },
+    { ext: '.jsx', typeIncludes: ['jsx', 'react'] },
+    { ext: '.css', typeIncludes: ['css'] },
+    { ext: '.svg', typeIncludes: ['svg'] },
+    { ext: '.md', typeIncludes: ['markdown'], typeEquals: 'md' },
+];
 // The on-disk extension a persist path would pick from the artifact's type/identifier.
 function artifactExtensionForAttrs(attrs) {
     const type = (attrs['type'] || '').toLowerCase();
     const identifier = (attrs['identifier'] || '').toLowerCase();
-    if (type.includes('tsx') || identifier.endsWith('.tsx'))
-        return '.tsx';
-    if (type.includes('jsx') || type.includes('react') || identifier.endsWith('.jsx'))
-        return '.jsx';
-    if (type.includes('css') || identifier.endsWith('.css'))
-        return '.css';
-    if (type.includes('svg') || identifier.endsWith('.svg'))
-        return '.svg';
-    if (type.includes('markdown') || type === 'md' || identifier.endsWith('.md'))
-        return '.md';
-    return '.html';
+    const rule = EXTENSION_RULES.find((r) => identifier.endsWith(r.ext) || r.typeEquals === type || r.typeIncludes.some((hint) => type.includes(hint)));
+    return rule?.ext ?? '.html';
 }
 // The slug a persist path would derive the file name from.
 function artifactBaseNameForAttrs(attrs) {
@@ -234,38 +237,26 @@ export function summarizeArtifactsForTranscript({ content, persistedFiles }) {
     let result = '';
     let cursor = 0;
     // Recompute skip ranges per iteration against the remaining tail so indices
-    // stay valid as we consume the string left to right.
-    while (cursor <= content.length) {
+    // stay valid as we consume the string left to right. Each iteration either
+    // returns or consumes at least one whole block, so the loop terminates.
+    for (;;) {
         const tail = content.slice(cursor);
-        const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges({ buffer: tail });
-        const ranges = unclosedFenceStart !== null ? [...baseRanges, [unclosedFenceStart, tail.length]] : baseRanges;
-        const open = findRealOpen(tail, 0, ranges);
-        if (open === -1) {
-            result += tail;
-            break;
-        }
-        const gt = tail.indexOf('>', open);
-        if (gt === -1) {
-            result += tail;
-            break;
-        }
-        const end = findUnskipped(tail, CLOSE, gt, ranges);
-        if (end === -1) {
-            // Real open but no real close — refuse to summarize (safer than eating
-            // to end-of-string on a malformed/streaming tag). Keep the rest as-is.
-            result += tail;
-            break;
-        }
-        const attrs = parseQuotedAttrs({ raw: tail.slice(open, gt) });
+        const block = findCompleteArtifactBlock({ content: tail, ranges: completeContentSkipRanges({ content: tail }) });
+        // No real open, an open tag that never terminates, or a real open but no
+        // real close — refuse to summarize (safer than eating to end-of-string on
+        // a malformed/streaming tag). Keep the rest as-is.
+        if (!block)
+            return result + tail;
+        const afterBlock = block.close + CLOSE.length;
+        const attrs = parseQuotedAttrs({ raw: tail.slice(block.open, block.openEnd) });
         const persisted = matchPersistedArtifactFile({ attrs: attrs, persistedFiles: persistedFiles });
         result += persisted
-            ? tail.slice(0, open) + artifactTranscriptSummary(attrs, persisted)
+            ? tail.slice(0, block.open) + artifactTranscriptSummary(attrs, persisted)
             : // Unconfirmed save — the transcript copy may be the only surviving
                 // body. Keep the block verbatim and keep scanning past it.
-                tail.slice(0, end + CLOSE.length);
-        cursor += end + CLOSE.length;
+                tail.slice(0, afterBlock);
+        cursor += afterBlock;
     }
-    return result;
 }
 function artifactTranscriptSummary(attrs, persisted) {
     const id = attrs['identifier'] ?? '';
@@ -295,8 +286,7 @@ function artifactTranscriptSummary(attrs, persisted) {
  * @complexity O(n) in `content.length`.
  */
 export function splitStreamingArtifact({ content }) {
-    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges({ buffer: content });
-    const ranges = unclosedFenceStart !== null ? [...baseRanges, [unclosedFenceStart, content.length]] : baseRanges;
+    const ranges = completeContentSkipRanges({ content });
     const open = findRealOpen(content, 0, ranges);
     if (open === -1)
         return { head: content, live: null };

package/dist/core/util/validate.js

@@ -162,34 +162,32 @@ function pathnameOnly(path) {
 function srcsetCandidateUrls(srcset) {
     const candidates = [];
     let start = 0;
-    let sawCandidate = false;
-    let dataUrlCandidate = false;
-    let sawWhitespaceAfterUrl = false;
+    let candidate = null;
     for (let index = 0; index < srcset.length; index += 1) {
         const char = srcset[index];
-        if (!sawCandidate) {
-            if (char === ',' || /\s/.test(char)) {
-                start = index + 1;
-                continue;
-            }
-            sawCandidate = true;
-            dataUrlCandidate = /^data:/i.test(srcset.slice(index));
-        }
-        if (/\s/.test(char)) {
-            sawWhitespaceAfterUrl = true;
+        const isSpace = /\s/.test(char);
+        if (candidate === null && (char === ',' || isSpace)) {
+            start = index + 1;
             continue;
         }
-        if (char === ',' && (!dataUrlCandidate || sawWhitespaceAfterUrl)) {
+        candidate ??= { isDataUrl: /^data:/i.test(srcset.slice(index)), sawWhitespaceAfterUrl: false };
+        if (isSpace) {
+            candidate.sawWhitespaceAfterUrl = true;
+        }
+        else if (endsSrcsetCandidate(candidate, char)) {
             candidates.push(srcset.slice(start, index));
             start = index + 1;
-            sawCandidate = false;
-            dataUrlCandidate = false;
-            sawWhitespaceAfterUrl = false;
+            candidate = null;
         }
     }
     candidates.push(srcset.slice(start));
     return candidates.map(firstUrlToken).filter(Boolean);
 }
+// A data: URL may itself contain commas, so for one a comma only ends the
+// candidate once whitespace has separated the URL from its descriptor.
+function endsSrcsetCandidate(candidate, char) {
+    return char === ',' && (!candidate.isDataUrl || candidate.sawWhitespaceAfterUrl);
+}
 function firstUrlToken(value) {
     // `String.split()` on a regex separator always returns at least one
     // element (even `''.split(/\s+/)` is `['']`), so `[0]` is never