@jini-ai/chat 0.3.10 → 0.5.0

package/dist/core/transcript.d.ts

@@ -5,18 +5,20 @@
  * the flattened text a host sends to an agent as prior-turn context.
  *
  * Adapted from OD's `providers/daemon.ts` transcript section (see
- * source-map.md). The OD original also owned SSE/fetch transport
+ * archived provenance ledger). The OD original also owned SSE/fetch transport
  * (`streamViaDaemon`, `DaemonStreamHandlers`) — none of that is ported here;
  * only the pure string-assembly helpers. It also hard-coded OD's BYOK/
  * OpenCode agent-family policy and an `agent-browser`-tool-specific
  * context-warning heuristic; both are OD product policy, not generic
  * transcript assembly, so they are generalized into caller-supplied hooks
- * (or dropped) below — see source-map.md for the full accounting.
+ * (or dropped) below — see archived provenance ledger for the full accounting.
  */
 import type { ChatMessage } from './messages.js';
 import type { PersistedArtifactFileRef } from './util/strip.js';
 /** The most recent `user`-authored message's content, or `''` if there isn't one. */
-export declare function latestUserPromptFromHistory(history: ChatMessage[]): string;
+export declare function latestUserPromptFromHistory({ history }: {
+    history: ChatMessage[];
+}): string;
 /**
  * Strip transcript-echo hazards from a prior assistant turn before it goes
  * back to the agent as history: an already-answered `<question-form>` /
@@ -36,7 +38,11 @@ export declare function latestUserPromptFromHistory(history: ChatMessage[]): str
  * @complexity O(n) in `content.length` (a small fixed number of regex
  *   passes) plus {@link summarizeArtifactsForTranscript}'s cost.
  */
-export declare function sanitizePriorAssistantTurn(content: string, persistedArtifactFiles?: ReadonlyArray<PersistedArtifactFileRef>): string;
+export declare function sanitizePriorAssistantTurn({ content }: {
+    content: string;
+}, { persistedArtifactFiles }?: {
+    persistedArtifactFiles?: (ReadonlyArray<PersistedArtifactFileRef>) | undefined;
+}): string;
 export interface BuildTranscriptOptions {
     /**
      * Scope the transcript to messages from this agent's family onward,
@@ -77,5 +83,7 @@ export interface BuildTranscriptOptions {
  *   scope, one to sanitize/truncate/join each message, one to scan events
  *   for the warning.
  */
-export declare function buildTranscript(history: ChatMessage[], options?: BuildTranscriptOptions): string;
+export declare function buildTranscript({ history }: {
+    history: ChatMessage[];
+}, options?: BuildTranscriptOptions): string;
 //# sourceMappingURL=transcript.d.ts.map

package/dist/core/transcript.js

@@ -3,7 +3,7 @@ const DEFAULT_MAX_TRANSCRIPT_MESSAGE_CHARS = 12_000;
 const DEFAULT_LARGE_TOOL_RESULT_CHARS = 8_000;
 const DEFAULT_HIGH_INPUT_TOKEN_WARNING_THRESHOLD = 200_000;
 /** The most recent `user`-authored message's content, or `''` if there isn't one. */
-export function latestUserPromptFromHistory(history) {
+export function latestUserPromptFromHistory({ history }) {
     for (let i = history.length - 1; i >= 0; i -= 1) {
         const message = history[i];
         if (message?.role === 'user')
@@ -82,7 +82,7 @@ function scopeHistoryToAgent(history, targetAgentId, isSameAgentFamily) {
  * @complexity O(n) in `content.length` (a small fixed number of regex
  *   passes) plus {@link summarizeArtifactsForTranscript}'s cost.
  */
-export function sanitizePriorAssistantTurn(content, persistedArtifactFiles = []) {
+export function sanitizePriorAssistantTurn({ content }, { persistedArtifactFiles = [] } = {}) {
     let sanitized = content.replace(
     // `\1` backreference keeps the open/close tag names matched so this never
     // splices across a `<question-form>…</ask-question>` mismatch.
@@ -99,7 +99,7 @@ export function sanitizePriorAssistantTurn(content, persistedArtifactFiles = [])
     // 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).
-    sanitized = summarizeArtifactsForTranscript(sanitized, persistedArtifactFiles);
+    sanitized = summarizeArtifactsForTranscript({ content: sanitized, persistedFiles: persistedArtifactFiles });
     return sanitized;
 }
 /**
@@ -113,7 +113,7 @@ export function sanitizePriorAssistantTurn(content, persistedArtifactFiles = [])
  *   scope, one to sanitize/truncate/join each message, one to scan events
  *   for the warning.
  */
-export function buildTranscript(history, options = {}) {
+export function buildTranscript({ history }, options = {}) {
     const maxMessageChars = options.maxMessageChars ?? DEFAULT_MAX_TRANSCRIPT_MESSAGE_CHARS;
     const largeToolResultChars = options.largeToolResultChars ?? DEFAULT_LARGE_TOOL_RESULT_CHARS;
     const highInputTokenWarningThreshold = options.highInputTokenWarningThreshold ?? DEFAULT_HIGH_INPUT_TOKEN_WARNING_THRESHOLD;
@@ -123,7 +123,7 @@ export function buildTranscript(history, options = {}) {
     const transcript = scopedHistory
         .map((m) => {
         const trimmed = m.content.trim();
-        const sanitized = m.role === 'assistant' ? sanitizePriorAssistantTurn(trimmed, resolvePersistedArtifactFiles(m)) : trimmed;
+        const sanitized = m.role === 'assistant' ? sanitizePriorAssistantTurn({ content: trimmed }, { persistedArtifactFiles: resolvePersistedArtifactFiles(m) }) : trimmed;
         return `## ${m.role}\n${escapeTranscriptRoleDelimiters(truncateForTranscript(sanitized, maxMessageChars))}`;
     })
         .join('\n\n');

package/dist/core/util/manifest.d.ts

@@ -6,7 +6,9 @@
  */
 import type { ArtifactManifest } from './types.js';
 /** The manifest sidecar file name convention for a given artifact entry file name. */
-export declare function artifactManifestNameFor(entry: string): string;
+export declare function artifactManifestNameFor({ entry }: {
+    entry: string;
+}): string;
 /** Build a fresh, complete manifest for a newly-persisted HTML artifact. */
 export declare function createHtmlArtifactManifest(input: {
     entry: string;
@@ -15,7 +17,9 @@ export declare function createHtmlArtifactManifest(input: {
     sourceSkillId?: string;
     designSystemId?: string | null;
 }): ArtifactManifest;
-export declare function serializeArtifactManifest(manifest: ArtifactManifest): string;
+export declare function serializeArtifactManifest({ manifest }: {
+    manifest: ArtifactManifest;
+}): string;
 /**
  * Parse and validate a manifest JSON string, rejecting anything that isn't a
  * well-formed, currently-supported manifest (wrong version, missing
@@ -25,7 +29,9 @@ export declare function serializeArtifactManifest(manifest: ArtifactManifest): s
  * @returns The validated manifest, or `null` on any parse/shape failure.
  * @complexity O(k) in the manifest's own field/array count — no I/O.
  */
-export declare function parseArtifactManifest(raw: string): ArtifactManifest | null;
+export declare function parseArtifactManifest({ raw }: {
+    raw: string;
+}): ArtifactManifest | null;
 /**
  * Infer a manifest for a legacy artifact file that predates manifest
  * sidecars, from its entry file name alone (extension → kind → renderer).

package/dist/core/util/manifest.js

@@ -55,7 +55,7 @@ function exportsForKind(kind) {
     return ['html', 'pdf', 'zip'];
 }
 /** The manifest sidecar file name convention for a given artifact entry file name. */
-export function artifactManifestNameFor(entry) {
+export function artifactManifestNameFor({ entry }) {
     return `${entry}.artifact.json`;
 }
 /** Build a fresh, complete manifest for a newly-persisted HTML artifact. */
@@ -77,7 +77,7 @@ export function createHtmlArtifactManifest(input) {
         metadata: input.metadata,
     };
 }
-export function serializeArtifactManifest(manifest) {
+export function serializeArtifactManifest({ manifest }) {
     return JSON.stringify(manifest, null, 2);
 }
 /**
@@ -89,7 +89,7 @@ export function serializeArtifactManifest(manifest) {
  * @returns The validated manifest, or `null` on any parse/shape failure.
  * @complexity O(k) in the manifest's own field/array count — no I/O.
  */
-export function parseArtifactManifest(raw) {
+export function parseArtifactManifest({ raw }) {
     try {
         const parsed = JSON.parse(raw);
         if (parsed?.version !== MANIFEST_VERSION)

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

@@ -22,7 +22,10 @@ export declare const INLINE_CODE_RE: RegExp;
  * continuation (e.g. `<artifactual`) is a prefix-shared literal that must
  * not be treated as a tag.
  */
-export declare function isRealArtifactOpenAt(content: string, idx: number): boolean;
+export declare function isRealArtifactOpenAt({ content, idx }: {
+    content: string;
+    idx: number;
+}): boolean;
 export type Range = readonly [number, number];
 /**
  * Compute the half-open `[start, end)` ranges of `buffer` that a Markdown
@@ -38,10 +41,15 @@ export type Range = readonly [number, number];
  * @complexity O(n) in `buffer.length` — one line-by-line scan plus one
  *   backtick scan per accumulated paragraph block.
  */
-export declare function computeSkipRanges(buffer: string): {
+export declare function computeSkipRanges({ buffer }: {
+    buffer: string;
+}): {
     ranges: Range[];
     unclosedFenceStart: number | null;
 };
 /** `true` when position `p` falls inside one of `ranges` (half-open intervals). */
-export declare function rangeContains(ranges: ReadonlyArray<Range>, p: number): boolean;
+export declare function rangeContains({ ranges, p }: {
+    ranges: ReadonlyArray<Range>;
+    p: number;
+}): boolean;
 //# sourceMappingURL=markdown-context.d.ts.map

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

@@ -34,7 +34,7 @@ const OL_ITEM_RE = /^\s*\d+\.\s+/;
  * continuation (e.g. `<artifactual`) is a prefix-shared literal that must
  * not be treated as a tag.
  */
-export function isRealArtifactOpenAt(content, idx) {
+export function isRealArtifactOpenAt({ content, idx }) {
     const next = content.charAt(idx + '<artifact'.length);
     return next !== '' && /\s/.test(next);
 }
@@ -52,7 +52,7 @@ export function isRealArtifactOpenAt(content, idx) {
  * @complexity O(n) in `buffer.length` — one line-by-line scan plus one
  *   backtick scan per accumulated paragraph block.
  */
-export function computeSkipRanges(buffer) {
+export function computeSkipRanges({ buffer }) {
     const ranges = [];
     // Paragraph-block regions are contiguous spans of paragraph lines outside
     // any fenced code block; inline-code scanning is restricted to one block at
@@ -115,7 +115,7 @@ export function computeSkipRanges(buffer) {
     return { ranges, unclosedFenceStart: inFence ? fenceStart : null };
 }
 /** `true` when position `p` falls inside one of `ranges` (half-open intervals). */
-export function rangeContains(ranges, p) {
+export function rangeContains({ ranges, p }) {
     for (const [s, e] of ranges) {
         if (p >= s && p < e)
             return true;

package/dist/core/util/markup-attributes.d.ts

@@ -16,5 +16,7 @@
  * Parse `name="value"` / `name='value'` pairs out of a tag's raw attribute
  * string (the content between the tag name and the closing `>`).
  */
-export declare function parseQuotedAttrs(raw: string): Record<string, string>;
+export declare function parseQuotedAttrs({ raw }: {
+    raw: string;
+}): Record<string, string>;
 //# sourceMappingURL=markup-attributes.d.ts.map

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

@@ -16,7 +16,7 @@
  * Parse `name="value"` / `name='value'` pairs out of a tag's raw attribute
  * string (the content between the tag name and the closing `>`).
  */
-export function parseQuotedAttrs(raw) {
+export function parseQuotedAttrs({ raw }) {
     const re = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
     const out = {};
     let m = re.exec(raw);

package/dist/core/util/parser.d.ts

@@ -16,7 +16,7 @@ export type ArtifactEvent = {
     fullContent: string;
 };
 /**
- * Create a fresh streaming artifact parser. Call `feed(delta)` for each
+ * Create a fresh streaming artifact parser. Call `feed({ delta })` for each
  * chunk as it arrives (iterate its generator to drain queued events), and
  * `flush()` once at end-of-stream to emit whatever is still buffered.
  *
@@ -25,9 +25,11 @@ export type ArtifactEvent = {
  *   the generator), which is the standard tradeoff for streaming tag
  *   detection over an ever-growing buffer.
  */
-export declare function createArtifactParser(): {
-    feed: (delta: string) => Generator<ArtifactEvent>;
-    flush: () => Generator<ArtifactEvent>;
+export declare function createArtifactParser(_requiredArgs: Record<string, never>): {
+    feed: (args: {
+        delta: string;
+    }) => Generator<ArtifactEvent>;
+    flush: (args: Record<string, never>) => Generator<ArtifactEvent>;
 };
 /**
  * Convenience wrapper over {@link createArtifactParser} for the common
@@ -38,5 +40,7 @@ export declare function createArtifactParser(): {
  * @param content - A complete (already fully-arrived) message body.
  * @complexity O(n) in `content.length` (one `feed` + one `flush` over the whole string).
  */
-export declare function parseArtifacts(content: string): ArtifactEvent[];
+export declare function parseArtifacts({ content }: {
+    content: string;
+}): ArtifactEvent[];
 //# sourceMappingURL=parser.d.ts.map

package/dist/core/util/parser.js

@@ -24,7 +24,7 @@ const CLOSE_TAG = '</artifact>';
 //     future chunk may turn it into an inline code span.
 function findOpenTag(buffer) {
     const len = buffer.length;
-    const { ranges, unclosedFenceStart } = computeSkipRanges(buffer);
+    const { ranges, unclosedFenceStart } = computeSkipRanges({ buffer: buffer });
     // 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
@@ -35,7 +35,7 @@ function findOpenTag(buffer) {
         const idx = buffer.indexOf(OPEN_PREFIX, from);
         if (idx === -1)
             break;
-        if (rangeContains(ranges, idx)) {
+        if (rangeContains({ ranges: ranges, p: idx })) {
             from = idx + OPEN_PREFIX.length;
             continue;
         }
@@ -53,7 +53,7 @@ function findOpenTag(buffer) {
                 earliestPartialOpen = idx;
             break;
         }
-        if (!isRealArtifactOpenAt(buffer, idx)) {
+        if (!isRealArtifactOpenAt({ content: buffer, idx: idx })) {
             from = after; // e.g. "<artifactual" — not a real open, keep scanning
             continue;
         }
@@ -101,7 +101,7 @@ function findOpenTag(buffer) {
     for (let k = lastNl + 1; k < len; k++) {
         if (buffer.charAt(k) !== '`')
             continue;
-        if (rangeContains(ranges, k))
+        if (rangeContains({ ranges: ranges, p: k }))
             continue;
         if (parity === 0) {
             firstUnmatched = k;
@@ -115,7 +115,7 @@ function findOpenTag(buffer) {
     note(firstUnmatched);
     // Strict prefix at the tail (e.g. "<art") — hold back.
     const tailLt = buffer.lastIndexOf('<');
-    if (tailLt !== -1 && !rangeContains(ranges, tailLt)) {
+    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);
@@ -126,7 +126,7 @@ function findOpenTag(buffer) {
     return { kind: 'none' };
 }
 /**
- * Create a fresh streaming artifact parser. Call `feed(delta)` for each
+ * Create a fresh streaming artifact parser. Call `feed({ delta })` for each
  * chunk as it arrives (iterate its generator to drain queued events), and
  * `flush()` once at end-of-stream to emit whatever is still buffered.
  *
@@ -135,7 +135,7 @@ function findOpenTag(buffer) {
  *   the generator), which is the standard tradeoff for streaming tag
  *   detection over an ever-growing buffer.
  */
-export function createArtifactParser() {
+export function createArtifactParser(_requiredArgs) {
     const state = {
         inside: false,
         buffer: '',
@@ -144,7 +144,7 @@ export function createArtifactParser() {
         title: '',
         content: '',
     };
-    function* feed(delta) {
+    function* feed({ delta }) {
         state.buffer += delta;
         while (state.buffer.length > 0) {
             if (!state.inside) {
@@ -164,7 +164,7 @@ export function createArtifactParser() {
                 if (open.start > 0) {
                     yield { type: 'text', delta: state.buffer.slice(0, open.start) };
                 }
-                const attrs = parseQuotedAttrs(open.attrs);
+                const attrs = parseQuotedAttrs({ raw: open.attrs });
                 state.inside = true;
                 state.identifier = attrs['identifier'] ?? '';
                 state.artifactType = attrs['type'] ?? '';
@@ -205,7 +205,7 @@ export function createArtifactParser() {
             state.content = '';
         }
     }
-    function* flush() {
+    function* flush(_requiredArgs) {
         if (state.inside) {
             if (state.buffer.length > 0) {
                 state.content += state.buffer;
@@ -231,8 +231,8 @@ export function createArtifactParser() {
  * @param content - A complete (already fully-arrived) message body.
  * @complexity O(n) in `content.length` (one `feed` + one `flush` over the whole string).
  */
-export function parseArtifacts(content) {
-    const parser = createArtifactParser();
-    return [...parser.feed(content), ...parser.flush()];
+export function parseArtifacts({ content }) {
+    const parser = createArtifactParser({});
+    return [...parser.feed({ delta: content }), ...parser.flush({})];
 }
 //# sourceMappingURL=parser.js.map

package/dist/core/util/recover.d.ts

@@ -27,7 +27,9 @@ export declare function recoverHtmlArtifactFromPrecedingDocument({ artifactHtml,
  */
 export declare function resolvePersistedArtifactHtml(input: RecoverHtmlArtifactInput): string;
 /** Recover a complete `<html>…</html>` document that IS the entire (trimmed) `sourceText`, or `null` otherwise. */
-export declare function recoverStandaloneHtmlDocument(sourceText: string | null | undefined): string | null;
+export declare function recoverStandaloneHtmlDocument({ sourceText }: {
+    sourceText: string | null | undefined;
+}): string | null;
 /**
  * Recover a complete HTML document from a *single* ```html fenced block in
  * `sourceText`. Returns `null` when there is no such fence, more than one
@@ -35,6 +37,8 @@ export declare function recoverStandaloneHtmlDocument(sourceText: string | null
  * candidates are ambiguous about which one is "the" artifact, so none is
  * chosen automatically.
  */
-export declare function recoverHtmlDocumentFromMarkdownFence(sourceText: string | null | undefined): string | null;
+export declare function recoverHtmlDocumentFromMarkdownFence({ sourceText }: {
+    sourceText: string | null | undefined;
+}): string | null;
 export {};
 //# sourceMappingURL=recover.d.ts.map

package/dist/core/util/recover.js

@@ -44,7 +44,7 @@ function lastIndexOfRegex(re, text) {
 export function recoverHtmlArtifactFromPrecedingDocument({ artifactHtml, identifier, sourceText }) {
     if (!sourceText)
         return null;
-    if (validateHtmlArtifact(artifactHtml).ok)
+    if (validateHtmlArtifact({ content: artifactHtml }).ok)
         return null;
     const artifactOpen = findLastArtifactOpen(sourceText, identifier);
     if (artifactOpen === -1)
@@ -67,7 +67,7 @@ export function recoverHtmlArtifactFromPrecedingDocument({ artifactHtml, identif
     const adjacentDoctype = beforeHtmlOpen.match(ADJACENT_DOCTYPE_RE);
     const htmlStart = adjacentDoctype ? htmlOpenStart - adjacentDoctype[0].length : htmlOpenStart;
     const candidate = beforeArtifact.slice(htmlStart, htmlClose + closeMatch[0].length).trim();
-    return validateHtmlArtifact(candidate).ok ? candidate : null;
+    return validateHtmlArtifact({ content: candidate }).ok ? candidate : null;
 }
 /**
  * Resolve the HTML that should actually be persisted for an artifact. When
@@ -84,11 +84,11 @@ export function resolvePersistedArtifactHtml(input) {
     return recoverHtmlArtifactFromPrecedingDocument(input) ?? input.artifactHtml;
 }
 /** Recover a complete `<html>…</html>` document that IS the entire (trimmed) `sourceText`, or `null` otherwise. */
-export function recoverStandaloneHtmlDocument(sourceText) {
+export function recoverStandaloneHtmlDocument({ sourceText }) {
     const candidate = String(sourceText || '').replace(/^/, '').trim();
     if (!/<\/html\s*>$/i.test(candidate))
         return null;
-    return validateHtmlArtifact(candidate).ok ? candidate : null;
+    return validateHtmlArtifact({ content: candidate }).ok ? candidate : null;
 }
 /**
  * Recover a complete HTML document from a *single* ```html fenced block in
@@ -97,7 +97,7 @@ export function recoverStandaloneHtmlDocument(sourceText) {
  * candidates are ambiguous about which one is "the" artifact, so none is
  * chosen automatically.
  */
-export function recoverHtmlDocumentFromMarkdownFence(sourceText) {
+export function recoverHtmlDocumentFromMarkdownFence({ sourceText }) {
     const text = String(sourceText || '');
     HTML_FENCE_RE.lastIndex = 0;
     let recovered = null;
@@ -107,7 +107,7 @@ export function recoverHtmlDocumentFromMarkdownFence(sourceText) {
         const candidate = (match[1] || '').replace(/^/, '').trim();
         if (!/<\/html\s*>$/i.test(candidate))
             continue;
-        if (!validateHtmlArtifact(candidate).ok)
+        if (!validateHtmlArtifact({ content: candidate }).ok)
             continue;
         recovered = candidate;
         count += 1;

package/dist/core/util/strip.d.ts

@@ -14,7 +14,9 @@
  * @complexity O(n) in `content.length` — one skip-range computation plus a
  *   pair of linear scans for the open/close tags.
  */
-export declare function stripArtifact(content: string): string;
+export declare function stripArtifact({ content }: {
+    content: string;
+}): string;
 /**
  * Display-only cleanup for a fallback shape some models emit: a complete
  * HTML document as a standalone reply, or as a single ```html fenced block,
@@ -29,7 +31,11 @@ export declare function stripArtifact(content: string): string;
  *
  * @complexity O(n) in `content.length` (plus one bounded regex scan over `sourceText` for the fence-recovery path).
  */
-export declare function stripRecoveredHtmlFallbackForDisplay(content: string, sourceText?: string): string;
+export declare function stripRecoveredHtmlFallbackForDisplay({ content }: {
+    content: string;
+}, { sourceText }?: {
+    sourceText?: (string) | undefined;
+}): string;
 /**
  * A persisted file a host confirms an artifact save wrote to storage.
  * `identifier` is the artifact manifest's `metadata.identifier` when present
@@ -48,7 +54,10 @@ export interface PersistedArtifactFileRef {
  *
  * @complexity O(m) in `persistedFiles.length` (linear `find`s).
  */
-export declare function matchPersistedArtifactFile(attrs: Record<string, string>, persistedFiles: ReadonlyArray<PersistedArtifactFileRef>): PersistedArtifactFileRef | null;
+export declare function matchPersistedArtifactFile({ attrs, persistedFiles }: {
+    attrs: Record<string, string>;
+    persistedFiles: ReadonlyArray<PersistedArtifactFileRef>;
+}): PersistedArtifactFileRef | null;
 /**
  * Replace every real `<artifact …>…</artifact>` block whose body is
  * CONFIRMED persisted to a file with a one-line summary, for use in a
@@ -77,7 +86,10 @@ export declare function matchPersistedArtifactFile(attrs: Record<string, string>
  *   consumes at least one full artifact block or the remaining tail), times
  *   O(m) for the `persistedFiles` lookup per block.
  */
-export declare function summarizeArtifactsForTranscript(content: string, persistedFiles: ReadonlyArray<PersistedArtifactFileRef>): string;
+export declare function summarizeArtifactsForTranscript({ content, persistedFiles }: {
+    content: string;
+    persistedFiles: ReadonlyArray<PersistedArtifactFileRef>;
+}): string;
 export interface StreamingArtifact {
     artifactType: string;
     title: string;
@@ -105,7 +117,9 @@ export interface StreamingArtifact {
  *
  * @complexity O(n) in `content.length`.
  */
-export declare function splitStreamingArtifact(content: string): {
+export declare function splitStreamingArtifact({ content }: {
+    content: string;
+}): {
     head: string;
     live: StreamingArtifact | null;
 };

package/dist/core/util/strip.js

@@ -20,7 +20,7 @@ function findUnskipped(content, needle, fromIndex, ranges) {
         const idx = content.indexOf(needle, from);
         if (idx === -1)
             return -1;
-        if (!rangeContains(ranges, idx))
+        if (!rangeContains({ ranges: ranges, p: idx }))
             return idx;
         from = idx + needle.length;
     }
@@ -38,7 +38,7 @@ function findRealOpen(content, fromIndex, ranges) {
         const idx = content.indexOf(OPEN, from);
         if (idx === -1)
             return -1;
-        if (rangeContains(ranges, idx) || !isRealArtifactOpenAt(content, idx)) {
+        if (rangeContains({ ranges: ranges, p: idx }) || !isRealArtifactOpenAt({ content: content, idx: idx })) {
             from = idx + OPEN.length;
             continue;
         }
@@ -61,8 +61,8 @@ function findRealOpen(content, fromIndex, ranges) {
  * @complexity O(n) in `content.length` — one skip-range computation plus a
  *   pair of linear scans for the open/close tags.
  */
-export function stripArtifact(content) {
-    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges(content);
+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
@@ -86,7 +86,7 @@ function findSingleRecoverableHtmlFence(content) {
     let match = HTML_FENCE_RE.exec(content);
     while (match !== null) {
         const html = (match[1] || '').replace(/^/, '').trim();
-        if (recoverHtmlDocumentFromMarkdownFence(match[0]) === html) {
+        if (recoverHtmlDocumentFromMarkdownFence({ sourceText: match[0] }) === html) {
             recovered = { start: match.index, end: match.index + match[0].length, html };
             count += 1;
         }
@@ -95,7 +95,7 @@ function findSingleRecoverableHtmlFence(content) {
     return count === 1 ? recovered : null;
 }
 function findRecoverablePrecedingHtmlArtifact(sourceText) {
-    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges(sourceText);
+    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges({ buffer: sourceText });
     const ranges = unclosedFenceStart !== null ? [...baseRanges, [unclosedFenceStart, sourceText.length]] : baseRanges;
     let from = 0;
     // `findRealOpen` already returns -1 once `from` runs past `sourceText.length`
@@ -111,7 +111,7 @@ function findRecoverablePrecedingHtmlArtifact(sourceText) {
         const end = findUnskipped(sourceText, CLOSE, closeTag, ranges);
         if (end === -1)
             return null;
-        const attrs = parseQuotedAttrs(sourceText.slice(open, closeTag));
+        const attrs = parseQuotedAttrs({ raw: sourceText.slice(open, closeTag) });
         const recovered = recoverHtmlArtifactFromPrecedingDocument({
             artifactHtml: sourceText.slice(closeTag + 1, end),
             identifier: attrs['identifier'],
@@ -145,11 +145,11 @@ function stripRecoverablePrecedingHtml(content, sourceText) {
  *
  * @complexity O(n) in `content.length` (plus one bounded regex scan over `sourceText` for the fence-recovery path).
  */
-export function stripRecoveredHtmlFallbackForDisplay(content, sourceText = content) {
+export function stripRecoveredHtmlFallbackForDisplay({ content }, { sourceText = content } = {}) {
     const withoutPrecedingDocument = stripRecoverablePrecedingHtml(content, sourceText);
     if (withoutPrecedingDocument !== null)
         return withoutPrecedingDocument;
-    if (recoverStandaloneHtmlDocument(content))
+    if (recoverStandaloneHtmlDocument({ sourceText: content }))
         return '';
     const fence = findSingleRecoverableHtmlFence(content);
     if (!fence)
@@ -188,7 +188,7 @@ function artifactBaseNameForAttrs(attrs) {
  *
  * @complexity O(m) in `persistedFiles.length` (linear `find`s).
  */
-export function matchPersistedArtifactFile(attrs, persistedFiles) {
+export function matchPersistedArtifactFile({ attrs, persistedFiles }) {
     const identifier = attrs['identifier'] ?? '';
     if (identifier) {
         const byManifest = persistedFiles.find((f) => f.identifier === identifier);
@@ -228,7 +228,7 @@ export function matchPersistedArtifactFile(attrs, persistedFiles) {
  *   consumes at least one full artifact block or the remaining tail), times
  *   O(m) for the `persistedFiles` lookup per block.
  */
-export function summarizeArtifactsForTranscript(content, persistedFiles) {
+export function summarizeArtifactsForTranscript({ content, persistedFiles }) {
     if (persistedFiles.length === 0)
         return content;
     let result = '';
@@ -237,7 +237,7 @@ export function summarizeArtifactsForTranscript(content, persistedFiles) {
     // stay valid as we consume the string left to right.
     while (cursor <= content.length) {
         const tail = content.slice(cursor);
-        const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges(tail);
+        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) {
@@ -256,8 +256,8 @@ export function summarizeArtifactsForTranscript(content, persistedFiles) {
             result += tail;
             break;
         }
-        const attrs = parseQuotedAttrs(tail.slice(open, gt));
-        const persisted = matchPersistedArtifactFile(attrs, persistedFiles);
+        const attrs = parseQuotedAttrs({ raw: tail.slice(open, gt) });
+        const persisted = matchPersistedArtifactFile({ attrs: attrs, persistedFiles: persistedFiles });
         result += persisted
             ? tail.slice(0, open) + artifactTranscriptSummary(attrs, persisted)
             : // Unconfirmed save — the transcript copy may be the only surviving
@@ -294,8 +294,8 @@ function artifactTranscriptSummary(attrs, persisted) {
  *
  * @complexity O(n) in `content.length`.
  */
-export function splitStreamingArtifact(content) {
-    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges(content);
+export function splitStreamingArtifact({ content }) {
+    const { ranges: baseRanges, unclosedFenceStart } = computeSkipRanges({ buffer: content });
     const ranges = unclosedFenceStart !== null ? [...baseRanges, [unclosedFenceStart, content.length]] : baseRanges;
     const open = findRealOpen(content, 0, ranges);
     if (open === -1)
@@ -313,7 +313,7 @@ export function splitStreamingArtifact(content) {
     // A matching close means the block is complete; defer to stripArtifact.
     if (findUnskipped(content, CLOSE, gt, ranges) !== -1)
         return { head: content, live: null };
-    const attrs = parseQuotedAttrs(content.slice(open, gt));
+    const attrs = parseQuotedAttrs({ raw: content.slice(open, gt) });
     const artifactType = attrs['type'] ?? '';
     // Only HTML/text artifacts read as code. An unknown type (attrs not fully
     // parsed, or omitted) is treated as code-eligible since the dominant case

package/dist/core/util/validate.d.ts

@@ -46,5 +46,7 @@ export type HtmlArtifactValidationResult = {
  *
  * @complexity O(n) in `content.length` — a handful of linear regex scans.
  */
-export declare function validateHtmlArtifact(content: string): HtmlArtifactValidationResult;
+export declare function validateHtmlArtifact({ content }: {
+    content: string;
+}): HtmlArtifactValidationResult;
 //# sourceMappingURL=validate.d.ts.map

package/dist/core/util/validate.js

@@ -51,7 +51,7 @@ const CSS_IMPORT_RE = /@import\s+(?:url\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*?))\s*\
  *
  * @complexity O(n) in `content.length` — a handful of linear regex scans.
  */
-export function validateHtmlArtifact(content) {
+export function validateHtmlArtifact({ content }) {
     const trimmed = content.replace(/^/, '').trim();
     if (trimmed.length === 0) {
         return { ok: false, reason: 'empty content' };