@jini-ai/chat 0.6.15-rc.1 → 0.6.15

package/dist/core/transcript.js

@@ -1,3 +1,4 @@
+import { fencedCodeRanges } from './util/markdown-context.js';
 /**
  * @module transcript
  *
@@ -152,12 +153,7 @@ export function sanitizePriorAssistantTurn({ content }, { persistedArtifactFiles
     // Strip ```json (or plain ```) fenced blocks whose body matches the form
     // schema shape — `"questions": [` is the strongest tell. A generic JSON
     // snippet without that key is left intact.
-    sanitized = sanitized.replace(/```(?:json)?\s*\n([\s\S]*?)\n```/g, (match, body) => {
-        if (/"questions"\s*:\s*\[/.test(body)) {
-            return '[form schema was echoed here on a prior turn; stripped to avoid a loop.]';
-        }
-        return match;
-    });
+    sanitized = stripEchoedFormFences({ content: sanitized });
     // Replace prior-turn `<artifact>` HTML with a one-line summary for
     // artifacts CONFIRMED persisted (see summarizeArtifactsForTranscript's own
     // doc for why an unconfirmed save is left verbatim).
@@ -192,4 +188,15 @@ export function buildTranscript({ history }, options = {}) {
     const warning = buildPriorRunContextWarning(scopedHistory, largeToolResultChars, highInputTokenWarningThreshold);
     return warning ? `${warning}\n\n${transcript}` : transcript;
 }
+function stripEchoedFormFences({ content }) {
+    const chunks = [];
+    let copied = 0;
+    for (const range of fencedCodeRanges({ content, opener: /```(?:json)?/g })) {
+        if (!/"questions"\s*:\s*\[/.test(range.body))
+            continue;
+        chunks.push(content.slice(copied, range.start), '[form schema was echoed here on a prior turn; stripped to avoid a loop.]');
+        copied = range.end;
+    }
+    return chunks.join('') + content.slice(copied);
+}
 //# sourceMappingURL=transcript.js.map

package/dist/core/turn-usage.js

@@ -32,6 +32,9 @@ export function replySegments({ events }, _optional = {}) {
             started = false;
             continue;
         }
+        // Repeated delivery receipts are bookkeeping, never content of the reply they already split.
+        if (isReplyBoundary({ event }))
+            continue;
         const lateResult = event.kind === 'usage' && !started && segments.length > 1;
         started ||= producesReplyOutput({ event });
         segments[segments.length - (lateResult ? 2 : 1)].push(event);
@@ -52,8 +55,10 @@ function usageCost({ event, agentId, sessions }, _optional = {}) {
     const key = JSON.stringify([agentId, sessionId]);
     const chargedUsd = sessions.get(key)?.chargedUsd ?? 0;
     const cumulative = validCost(event.cumulativeCostUsd);
-    const cost = cumulative === undefined ? validCost(event.costUsd)
-        : cumulative < chargedUsd ? cumulative : cumulative - chargedUsd;
+    let snapshotCost;
+    if (cumulative !== undefined)
+        snapshotCost = cumulative < chargedUsd ? cumulative : cumulative - chargedUsd;
+    const cost = cumulative === undefined ? validCost(event.costUsd) : snapshotCost;
     // Interim interrupted-segment charges are already paid; later snapshots subtract them.
     // After a counter reset the new snapshot, rather than the old epoch's total, is the baseline.
     sessions.set(key, { sessionId, chargedUsd: cumulative ?? chargedUsd + (cost ?? 0) });
@@ -77,11 +82,14 @@ export function turnUsage({ events }, { sessions = new Map(), agentId = '' } = {
         if (event.stopReason !== undefined)
             total.stopReason = event.stopReason;
         const cost = usageCost({ event, agentId, sessions });
-        if (cost !== undefined)
-            total.costUsd = (total.costUsd ?? 0) + cost;
+        addReportedCost({ total, cost });
     }
     return total;
 }
+function addReportedCost({ total, cost }, _options = {}) {
+    if (cost !== undefined)
+        total.costUsd = (total.costUsd ?? 0) + cost;
+}
 /** Add an event's well-formed token and duration counts into `total`, in place. */
 function addReportedCounts({ total, event }, _optional = {}) {
     for (const field of ['inputTokens', 'outputTokens', 'durationMs']) {

package/dist/core/user-text-redaction.d.ts

@@ -1,8 +1,5 @@
-import type { ChatMessage } from './messages.js';
-export interface SecretRedactionSignal {
-    readonly secretRedacted: true;
-    readonly count: number;
-}
+import type { ChatMessage, SecretRedactionSignal } from './messages.js';
+export type { SecretRedactionSignal } from './messages.js';
 export interface UserTextRedaction {
     readonly text: string;
     readonly secretRedacted: boolean;

package/dist/core/user-text-redaction.js

@@ -10,9 +10,9 @@ const CHAT_RULES = [
     // Kept on top of the shared Slack rule: that rule refuses a token preceded by `-` (e.g. a URL path
     // segment `/-xoxb-…`) and the entropy fallback below exempts URLs, so without this rule such a token
     // would reach storage and model history. Only drop it once the shared rule covers that case.
-    { kind: 'chat_key', pattern: /(?<![A-Za-z0-9_])xox[baprs]-[A-Za-z0-9-]{16,}/g, replacement: () => INTERNAL_REMOVED },
+    { kind: 'chat_key', pattern: /(?<!\w)xox[baprs]-[A-Za-z0-9-]{16,}/g, replacement: () => INTERNAL_REMOVED },
     // Explicit authorization syntax catches even short values. Exempt scheme descriptions in prose.
-    { kind: 'chat_bearer', pattern: /\bBearer[ \t]+(?!\[REDACTED)(?!(?:token|tokens|authentication|authorization|auth|scheme|credentials?)\b)[A-Za-z0-9._~+\/=-]+/gi, replacement: () => 'Bearer ' + INTERNAL_REMOVED },
+    { kind: 'chat_bearer', pattern: /\bBearer[ \t]+(?!\[REDACTED)(?!(?:token|tokens|authentication|authorization|auth|scheme|credentials?)\b)[\w.~+\/=-]+/gi, replacement: () => 'Bearer ' + INTERNAL_REMOVED },
 ];
 function entropy(text) {
     const counts = new Map();
@@ -49,7 +49,7 @@ export function redactUserText({ text }, { secretField = false } = {}) {
             return candidate;
         const bits = entropy(candidate);
         const mixedAlphabet = /[A-Z]/.test(candidate) && /[a-z]/.test(candidate);
-        if (bits < 4 || (!/[0-9]/.test(candidate) && (!mixedAlphabet || bits < 4.5)))
+        if (bits < 4 || (!/\d/.test(candidate) && (!mixedAlphabet || bits < 4.5)))
             return candidate;
         count += 1;
         return INTERNAL_REMOVED;

package/dist/core/util/manifest.js

@@ -1,19 +1,21 @@
+const CODE_SNIPPET = 'code-snippet';
+const REACT_COMPONENT = 'react-component';
 const MANIFEST_VERSION = 1;
 const ALLOWED_KINDS = new Set([
     'html',
     'deck',
-    'react-component',
+    REACT_COMPONENT,
     'markdown-document',
     'svg',
     'diagram',
-    'code-snippet',
+    CODE_SNIPPET,
     'mini-app',
     'design-system',
 ]);
 const ALLOWED_RENDERERS = new Set([
     'html',
     'deck-html',
-    'react-component',
+    REACT_COMPONENT,
     'markdown',
     'svg',
     'diagram',
@@ -32,20 +34,20 @@ const LEGACY_KIND_BY_EXT = new Map([
     ['.htm', 'html'],
     ['.svg', 'svg'],
     ['.md', 'markdown-document'],
-    ['.jsx', 'react-component'],
-    ['.tsx', 'react-component'],
-    ['.js', 'code-snippet'],
-    ['.ts', 'code-snippet'],
-    ['.json', 'code-snippet'],
-    ['.css', 'code-snippet'],
+    ['.jsx', REACT_COMPONENT],
+    ['.tsx', REACT_COMPONENT],
+    ['.js', CODE_SNIPPET],
+    ['.ts', CODE_SNIPPET],
+    ['.json', CODE_SNIPPET],
+    ['.css', CODE_SNIPPET],
 ]);
 /** Renderer and export set for every kind `inferLegacyManifest` can resolve to (the inferred kinds plus the deck-name heuristic's `deck`). */
 const LEGACY_KIND_INFO = {
     html: { renderer: 'html', exports: ['html', 'pdf', 'zip'] },
     deck: { renderer: 'deck-html', exports: ['html', 'pdf', 'zip'] },
     'markdown-document': { renderer: 'markdown', exports: ['md', 'html', 'pdf', 'zip'] },
-    'react-component': { renderer: 'react-component', exports: ['jsx', 'html', 'zip'] },
-    'code-snippet': { renderer: 'code', exports: ['txt', 'zip'] },
+    [REACT_COMPONENT]: { renderer: REACT_COMPONENT, exports: ['jsx', 'html', 'zip'] },
+    [CODE_SNIPPET]: { renderer: 'code', exports: ['txt', 'zip'] },
     svg: { renderer: 'svg', exports: ['svg', 'zip'] }, // 'svg' is a valid ArtifactRendererId as-is
 };
 /** The manifest sidecar file name convention for a given artifact entry file name. */

package/dist/core/util/markdown-context.d.ts

@@ -52,4 +52,18 @@ export declare function rangeContains({ ranges, p }: {
     ranges: ReadonlyArray<Range>;
     p: number;
 }): boolean;
+export interface FencedCodeRange {
+    start: number;
+    end: number;
+    body: string;
+}
+/** Permissive model-output fences used for recovery/transcript cleanup, independent of the
+ * renderer's line-anchored fence grammar above. Opening whitespace is greedy through its last
+ * newline; an empty block may require giving that last newline back to the closing delimiter.
+ * Each opener and closing delimiter is scanned directly instead of backtracking across the body.
+ */
+export declare function fencedCodeRanges({ content, opener }: {
+    content: string;
+    opener: RegExp;
+}, _options?: {}): Generator<FencedCodeRange>;
 //# sourceMappingURL=markdown-context.d.ts.map

package/dist/core/util/markdown-context.js

@@ -98,19 +98,21 @@ function visitLineOutsideFence(scan, line) {
     if (line.hasNewline && FENCE_OPEN_RE.test(line.text)) {
         closeBlockBefore(scan, line.start);
         scan.fenceStart = line.start;
+        return;
     }
-    else if (line.text.trim() === '') {
+    if (line.text.trim() === '') {
         closeBlockBefore(scan, line.start);
+        return;
     }
-    else if (HEADING_RE.test(line.text) || UL_ITEM_RE.test(line.text) || OL_ITEM_RE.test(line.text)) {
+    if (HEADING_RE.test(line.text) || UL_ITEM_RE.test(line.text) || OL_ITEM_RE.test(line.text)) {
         // Each heading/list-item line is its own inline-scan region rather
         // than joining adjacent paragraphs.
         closeBlockBefore(scan, line.start);
         scan.blockRegions.push([line.start, line.end]);
+        return;
     }
-    else if (scan.blockStart === -1) {
+    if (scan.blockStart === -1)
         scan.blockStart = line.start;
-    }
 }
 /** `true` when position `p` falls inside one of `ranges` (half-open intervals). */
 export function rangeContains({ ranges, p }) {
@@ -120,4 +122,40 @@ export function rangeContains({ ranges, p }) {
     }
     return false;
 }
+/** Permissive model-output fences used for recovery/transcript cleanup, independent of the
+ * renderer's line-anchored fence grammar above. Opening whitespace is greedy through its last
+ * newline; an empty block may require giving that last newline back to the closing delimiter.
+ * Each opener and closing delimiter is scanned directly instead of backtracking across the body.
+ */
+export function* fencedCodeRanges({ content, opener }, _options = {}) {
+    const openings = new RegExp(opener.source, 'g');
+    let opening = openings.exec(content);
+    while (opening !== null) {
+        const body = fencedBodyRange({ content, after: opening.index + opening[0].length });
+        if (body === null)
+            return; // No later closing fence exists for any subsequent opener either.
+        if (body !== undefined) {
+            yield { start: opening.index, end: body.end, body: content.slice(body.start, body.end - 4) };
+            openings.lastIndex = body.end;
+        }
+        opening = openings.exec(content);
+    }
+}
+/** Undefined is an invalid opener; null is a valid opener with no possible closing fence. */
+function fencedBodyRange({ content, after }) {
+    let whitespaceEnd = after;
+    while (whitespaceEnd < content.length && /\s/.test(content.charAt(whitespaceEnd)))
+        whitespaceEnd += 1;
+    const newlineOffset = content.slice(after, whitespaceEnd).indexOf('\n');
+    if (newlineOffset === -1)
+        return undefined;
+    const firstNewline = after + newlineOffset;
+    const lastNewline = content.lastIndexOf('\n', whitespaceEnd - 1);
+    const close = content.indexOf('\n```', lastNewline + 1);
+    if (close !== -1)
+        return { start: lastNewline + 1, end: close + 4 };
+    if (lastNewline === firstNewline || !content.startsWith('\n```', lastNewline))
+        return null;
+    return { start: content.lastIndexOf('\n', lastNewline - 1) + 1, end: lastNewline + 4 };
+}
 //# sourceMappingURL=markdown-context.js.map

package/dist/core/util/markup-attributes.js

@@ -17,7 +17,7 @@
  * string (the content between the tag name and the closing `>`).
  */
 export function parseQuotedAttrs({ raw }) {
-    const re = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+    const re = /(?<!\w)(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
     const out = {};
     let m = re.exec(raw);
     while (m !== null) {

package/dist/core/util/parser.js

@@ -86,13 +86,12 @@ function findTagEnd({ buffer, from }) {
         if (quote !== null) {
             if (c === quote)
                 quote = null;
+            continue;
         }
-        else if (c === '"' || c === "'") {
-            quote = c;
-        }
-        else if (c === '>') {
+        if (c === '>')
             return j;
-        }
+        if (c === '"' || c === "'")
+            quote = c;
     }
     return -1;
 }
@@ -198,7 +197,8 @@ export function createArtifactParser(_requiredArgs) {
         return true;
     }
     function* flush(_requiredArgs) {
-        if (state.inside) {
+        const wasInside = state.inside;
+        if (wasInside) {
             if (state.buffer.length > 0) {
                 state.content += state.buffer;
                 yield { type: 'artifact:chunk', identifier: state.identifier, delta: state.buffer };
@@ -206,7 +206,7 @@ export function createArtifactParser(_requiredArgs) {
             }
             yield { type: 'artifact:end', identifier: state.identifier, fullContent: state.content };
         }
-        else if (state.buffer.length > 0) {
+        if (!wasInside && state.buffer.length > 0) {
             yield { type: 'text', delta: state.buffer };
         }
         state.buffer = '';

package/dist/core/util/pointer.js

@@ -1,7 +1,24 @@
+import { trimChars } from '@jini-ai/core/primitives';
 const MAX_POINTER_TEXT_BYTES = 100;
-const POINTER_TARGET_RE = /^(?:见|see)(?:\s*[:：]\s*|\s+)[`"'“”‘’]?(.+?\.html?)[`"'“”‘’]?[.。]?$/iu;
+// Matching only runs after the 100-byte visible-text guard; bound each run to that same ceiling.
+const POINTER_TARGET_RE = /^(?:见|see)(?:\s{0,100}[:：]\s{0,100}|\s{1,100})[`"'“”‘’]?(.{1,100}?\.html?)[`"'“”‘’]?[.。]?$/iu;
 const SCRIPT_OR_STYLE_RE = /<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi;
-const HTML_TAG_RE = /<[^>]+>/g;
+function stripPointerTags(content) {
+    const chunks = [];
+    let copied = 0;
+    let open = content.indexOf('<');
+    while (open !== -1) {
+        const close = content.indexOf('>', open + 1);
+        if (close === -1)
+            break;
+        if (close > open + 1) {
+            chunks.push(content.slice(copied, open), ' ');
+            copied = close + 1;
+        }
+        open = content.indexOf('<', close + 1);
+    }
+    return chunks.join('') + content.slice(copied);
+}
 /**
  * Resolve a short "see foo.html"-style reply to the referenced file name, if
  * `content` is (after stripping tags) nothing but such a pointer and the
@@ -40,12 +57,11 @@ function resolveAgainstProjectFiles({ target, candidateFileName, projectFiles })
 function visiblePointerText(content) {
     const stripped = content
         .replace(/^/, '')
-        .replace(SCRIPT_OR_STYLE_RE, ' ')
-        .replace(HTML_TAG_RE, ' ');
-    return decodeBasicHtmlEntities(stripped).replace(/\s+/g, ' ').trim();
+        .replace(SCRIPT_OR_STYLE_RE, ' ');
+    return decodeBasicHtmlEntities(stripPointerTags(stripped)).replace(/\s+/g, ' ').trim();
 }
 function normalizeTarget(value) {
-    return value.trim().replace(/^[`"'“”‘’]+|[`"'“”‘’]+$/g, '');
+    return trimChars({ text: value.trim(), chars: "`\"'“”‘’" });
 }
 function isSafeHtmlTarget(value) {
     if (!/\.(?:html?|HTML?)$/.test(value))

package/dist/core/util/recover.js

@@ -6,10 +6,11 @@
  * a standalone document reply, or as a single fenced ```html block.
  */
 import { validateHtmlArtifact } from './validate.js';
+import { fencedCodeRanges } from './markdown-context.js';
 const HTML_OPEN_RE = /<html\b/gi;
 const HTML_CLOSE_RE = /<\/html\s*>/gi;
 const ADJACENT_DOCTYPE_RE = /<!doctype\s+html\b[^>]*>\s*$/i;
-const HTML_FENCE_RE = /```(?:html|HTML)\s*\n([\s\S]*?)\n```/g;
+const HTML_FENCE_RE = /```(?:html|HTML)/g;
 function findLastArtifactOpen(sourceText, identifier) {
     if (!identifier)
         return sourceText.lastIndexOf('<artifact');
@@ -99,15 +100,11 @@ export function recoverStandaloneHtmlDocument({ sourceText }) {
  */
 export function recoverHtmlDocumentFromMarkdownFence({ sourceText }) {
     const text = String(sourceText || '');
-    HTML_FENCE_RE.lastIndex = 0;
     let recovered = null;
     let count = 0;
-    let match;
-    while ((match = HTML_FENCE_RE.exec(text)) !== null) {
-        const candidate = (match[1] || '').replace(/^/, '').trim();
-        if (!/<\/html\s*>$/i.test(candidate))
-            continue;
-        if (!validateHtmlArtifact({ content: candidate }).ok)
+    for (const range of fencedCodeRanges({ content: text, opener: HTML_FENCE_RE })) {
+        const candidate = range.body.replace(/^/, '').trim();
+        if (!/<\/html\s*>$/i.test(candidate) || !validateHtmlArtifact({ content: candidate }).ok)
             continue;
         recovered = candidate;
         count += 1;

package/dist/core/util/strip.js

@@ -1,15 +1,16 @@
+import { trimChars } from '@jini-ai/core/primitives';
 /**
  * @module strip
  *
  * Post-stream `<artifact>` removal/summarization and the streaming-display
  * counterpart that surfaces an in-flight (not-yet-closed) artifact block.
  */
-import { computeSkipRanges, isRealArtifactOpenAt, rangeContains } from './markdown-context.js';
+import { fencedCodeRanges, computeSkipRanges, isRealArtifactOpenAt, rangeContains } from './markdown-context.js';
 import { parseQuotedAttrs } from './markup-attributes.js';
 import { recoverHtmlArtifactFromPrecedingDocument, recoverHtmlDocumentFromMarkdownFence, recoverStandaloneHtmlDocument, } from './recover.js';
 const OPEN = '<artifact';
 const CLOSE = '</artifact>';
-const HTML_FENCE_RE = /```(?:html|HTML)\s*\n([\s\S]*?)\n```/g;
+const HTML_FENCE_RE = /```(?:html|HTML)/g;
 function findUnskipped(content, needle, fromIndex, ranges) {
     let from = fromIndex;
     // `needle` (always `CLOSE`, non-empty) makes `content.indexOf` itself
@@ -91,17 +92,14 @@ export function stripArtifact({ content }) {
     return (content.slice(0, block.open) + content.slice(block.close + CLOSE.length)).trim();
 }
 function findSingleRecoverableHtmlFence(content) {
-    HTML_FENCE_RE.lastIndex = 0;
     let recovered = null;
     let count = 0;
-    let match = HTML_FENCE_RE.exec(content);
-    while (match !== null) {
-        const html = (match[1] || '').replace(/^/, '').trim();
-        if (recoverHtmlDocumentFromMarkdownFence({ sourceText: match[0] }) === html) {
-            recovered = { start: match.index, end: match.index + match[0].length, html };
+    for (const range of fencedCodeRanges({ content, opener: HTML_FENCE_RE })) {
+        const html = range.body.replace(/^/, '').trim();
+        if (recoverHtmlDocumentFromMarkdownFence({ sourceText: content.slice(range.start, range.end) }) === html) {
+            recovered = { start: range.start, end: range.end, html };
             count += 1;
         }
-        match = HTML_FENCE_RE.exec(content);
     }
     return count === 1 ? recovered : null;
 }
@@ -177,10 +175,9 @@ function artifactExtensionForAttrs(attrs) {
 }
 // The slug a persist path would derive the file name from.
 function artifactBaseNameForAttrs(attrs) {
-    return ((attrs['identifier'] || attrs['title'] || 'artifact')
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/g, '-')
-        .replace(/^-+|-+$/g, '')
+    return (trimChars({ text: (attrs['identifier'] || attrs['title'] || 'artifact')
+            .toLowerCase()
+            .replace(/[^a-z0-9_-]+/g, '-'), chars: '-' })
         .slice(0, 60) || 'artifact');
 }
 /**
@@ -296,7 +293,7 @@ export function splitStreamingArtifact({ content }) {
         // known yet, but an artifact is starting, so show the box (empty body)
         // and hide the partial `<artifact …` tail from Markdown.
         return {
-            head: content.slice(0, open).replace(/\s+$/, ''),
+            head: content.slice(0, open).trimEnd(),
             live: { artifactType: '', title: '', identifier: '', content: '' },
         };
     }
@@ -311,7 +308,7 @@ export function splitStreamingArtifact({ content }) {
     if (artifactType && !/html|text\//i.test(artifactType))
         return { head: content, live: null };
     return {
-        head: content.slice(0, open).replace(/\s+$/, ''),
+        head: content.slice(0, open).trimEnd(),
         live: {
             artifactType,
             title: attrs['title'] ?? '',

package/dist/core/util/validate.js

@@ -43,8 +43,9 @@ const URL_ATTRIBUTE_RE = /\b(href|src|srcset|poster|action|formaction|data|xlink
 const STYLE_ATTRIBUTE_RE = /\bstyle\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'`=<>]+))/gi;
 const HTML_TAG_RE = /<[a-z][^>]*>/gi;
 const STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
-const CSS_URL_RE = /\burl\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*?))\s*\)/gi;
-const CSS_IMPORT_RE = /@import\s+(?:url\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*?))\s*\)|"([^"]*)"|'([^']*)')/gi;
+const CSS_URL_RE = /\burl\((?:\s*"([^"]*)"\s*|\s*'([^']*)'\s*|([^)]*))\)/gi;
+const CSS_IMPORT_START_RE = /@import\s+/gi;
+const CSS_QUOTED_IMPORT_RE = /(?:"([^"]*)"|'([^']*)')/y;
 /**
  * Sniff-test whether `content` looks like a complete HTML document rather
  * than prose that happens to mention HTML.
@@ -127,22 +128,34 @@ function hasReservedWorkspacePathInStyleBlocks(content) {
     return false;
 }
 function cssTextReferencesReservedWorkspacePath(cssText) {
-    for (const pattern of [CSS_URL_RE, CSS_IMPORT_RE]) {
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(cssText)) !== null) {
-            // Both CSS_URL_RE and CSS_IMPORT_RE are single top-level alternations
-            // across all their capture groups, so exactly one group is ever defined
-            // on a successful match — `.find` always finds it; the assertion just
-            // satisfies `noUncheckedIndexedAccess`.
-            const candidate = match.slice(1).find((value) => value !== undefined);
-            if (candidateReferencesReservedWorkspacePath(candidate, false)) {
-                return true;
-            }
-        }
+    for (const match of cssReferenceMatches({ cssText })) {
+        // Quote/unquoted alternatives are mutually exclusive, so exactly one capture is defined
+        // after success; TypeScript cannot express that guarantee for RegExpExecArray.
+        const candidate = match.slice(1).find((value) => value !== undefined);
+        if (candidateReferencesReservedWorkspacePath(candidate, false))
+            return true;
     }
     return false;
 }
+/** Keep each import's whole span consumed, including URL imports already inspected by the first
+ * pass. Rescanning @import text quoted inside such a URL would change the path-refusal policy. */
+function* cssReferenceMatches({ cssText }) {
+    yield* cssText.matchAll(CSS_URL_RE);
+    const imports = new RegExp(CSS_IMPORT_START_RE);
+    const url = new RegExp(CSS_URL_RE.source, 'iy');
+    const quoted = new RegExp(CSS_QUOTED_IMPORT_RE);
+    let header = imports.exec(cssText);
+    while (header !== null) {
+        url.lastIndex = imports.lastIndex;
+        quoted.lastIndex = imports.lastIndex;
+        const value = url.exec(cssText) ?? quoted.exec(cssText);
+        if (value) {
+            imports.lastIndex = value.index + value[0].length;
+            yield value;
+        }
+        header = imports.exec(cssText);
+    }
+}
 function candidateReferencesReservedWorkspacePath(candidate, splitCandidates) {
     const paths = splitCandidates ? srcsetCandidateUrls(candidate) : [firstUrlToken(candidate)];
     return paths.some((path) => {
@@ -171,10 +184,9 @@ function srcsetCandidateUrls(srcset) {
             continue;
         }
         candidate ??= { isDataUrl: /^data:/i.test(srcset.slice(index)), sawWhitespaceAfterUrl: false };
-        if (isSpace) {
+        if (isSpace)
             candidate.sawWhitespaceAfterUrl = true;
-        }
-        else if (endsSrcsetCandidate(candidate, char)) {
+        if (!isSpace && endsSrcsetCandidate(candidate, char)) {
             candidates.push(srcset.slice(start, index));
             start = index + 1;
             candidate = null;

package/dist/embed-widget/browser/lazy-loader.js

@@ -1,3 +1,4 @@
+const ARIA_LABEL = 'aria-label';
 export { CHAT_BUBBLE_STYLE } from '../../contracts/chat-bubble-style.js';
 /**
  * Activates a host-rendered button without importing chat, React, icons or storage.
@@ -11,10 +12,10 @@ export function installLazyChatLoader(args, _options = {}) {
     let shouldOpen = false;
     let shouldFocus = false;
     const initialContent = args.button.innerHTML;
-    const label = args.button.getAttribute('aria-label') ?? '';
+    const label = args.button.getAttribute(ARIA_LABEL) ?? '';
     const activate = async ({ open = true, focus = open } = {}, _options = {}) => {
         if (disposed)
-            return;
+            return undefined;
         if (!pending) {
             shouldOpen = false;
             shouldFocus = false;
@@ -24,26 +25,29 @@ export function installLazyChatLoader(args, _options = {}) {
         if (pending)
             return pending;
         args.button.setAttribute('aria-busy', 'true');
-        args.button.setAttribute('aria-label', args.loadingLabel);
+        args.button.setAttribute(ARIA_LABEL, args.loadingLabel);
         args.button.textContent = args.loadingLabel;
         delete args.button.dataset.loadFailed;
         // Defer through a promise so a synchronous host load failure follows the same retry path.
-        pending = Promise.resolve().then(() => { if (!ready)
-            return args.load({}); }).then(() => {
+        pending = Promise.resolve().then(() => {
+            if (!ready)
+                return args.load({});
+            return undefined;
+        }).then(() => {
             if (disposed)
                 return;
             // Asset readiness survives an open failure; retry must never evaluate the script twice.
             ready = true;
             if (shouldOpen)
                 args.open({ focus: shouldFocus });
-            args.button.setAttribute('aria-label', label);
+            args.button.setAttribute(ARIA_LABEL, label);
             args.button.innerHTML = initialContent;
             args.button.hidden = true;
         }).catch(() => {
             if (!disposed) {
                 args.button.hidden = false;
                 args.button.dataset.loadFailed = 'true';
-                args.button.setAttribute('aria-label', args.retryLabel);
+                args.button.setAttribute(ARIA_LABEL, args.retryLabel);
                 args.button.textContent = args.retryLabel;
             }
         }).finally(() => {
@@ -62,17 +66,17 @@ export function installLazyChatLoader(args, _options = {}) {
     args.button.addEventListener('click', click);
     args.button.addEventListener('keydown', keydown);
     args.button.dataset.loaderReady = 'true';
-    if (args.resume || args.deepLink)
-        void activate({ focus: args.deepLink });
-    else if (args.preload)
-        void activate({ open: false });
+    if (args.resume || args.deepLink || args.preload) {
+        const resume = args.resume || args.deepLink;
+        void activate({ open: resume, focus: resume && args.deepLink });
+    }
     return {
         activate,
         dispose(_input = {}, _options = {}) {
             disposed = true;
             args.button.removeEventListener('click', click);
             args.button.removeEventListener('keydown', keydown);
-            args.button.setAttribute('aria-label', label);
+            args.button.setAttribute(ARIA_LABEL, label);
             args.button.innerHTML = initialContent;
             args.button.removeAttribute('aria-busy');
             delete args.button.dataset.loadFailed;

package/dist/embed-widget/react/dialog.hooks.js

@@ -25,11 +25,11 @@ export function useEmbedChatDialog({ open, onClose, panelRef, launcherRef }, { r
     }, [open, launcherRef]);
     useEffect(() => {
         if (!open)
-            return;
+            return undefined;
         const panel = panelRef.current;
         const view = panel?.ownerDocument.defaultView;
         if (!panel || !view)
-            return;
+            return undefined;
         const onKeyDown = (event) => {
             if (event.key === 'Escape' && !event.defaultPrevented) {
                 event.preventDefault();

package/dist/embed-widget/react/embed.js

@@ -36,7 +36,7 @@ export function EmbedChatWidget(args) {
     useEffect(() => {
         const queued = { value: session.drain({}) };
         if (!isQueuedPageAction(queued) || queued.value.type === 'navigate')
-            return;
+            return undefined;
         const action = queued.value;
         return scheduleFrame({ callback: () => { pageActions.execute({ action }); } });
     }, [session, pageActions, scheduleFrame]);

package/dist/embed-widget/react/header.hooks.js

@@ -15,7 +15,7 @@ export function useEmbedChatHeader({ hasMessages, onReset, keyboard }, _options
     }, [confirming]);
     useEffect(() => {
         if (!confirming)
-            return;
+            return undefined;
         return keyboard.subscribe({ onEscape: () => setConfirming(false) });
     }, [confirming, keyboard]);
     return { confirming, cancel, headerRef, resetButtonRef,

package/dist/embed-widget/transports/fetch-sse.js

@@ -151,7 +151,7 @@ async function deliverResponse({ run, args, response }) {
             await response.body?.cancel();
         }
         catch { /* closed body */ }
-        return;
+        return undefined;
     }
     if (!response.ok)
         return reportHttpFailure({ run, response, requestFailed: args.copy.requestFailed });
@@ -161,6 +161,7 @@ async function deliverResponse({ run, args, response }) {
         if (run.isSettled() || !dispatchFrame({ run, result: args.frameMapper({ frame }) }))
             break;
     }
+    return undefined;
 }
 async function reportHttpFailure({ run, response, requestFailed }) {
     const body = await response.json().catch(() => null);