@vertesia/ui 1.5.0-dev.20260722.120446Z → 1.5.0-dev.20260725.083715Z

package/src/widgets/markdown/MarkdownLink.test.tsx

@@ -0,0 +1,122 @@
+// @vitest-environment jsdom
+
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { type AgentResourceResolver, AgentResourceResolverProvider } from './AgentResourceResolver.js';
+import type { MarkdownLinkProps } from './MarkdownLink.js';
+import { MarkdownLink } from './MarkdownLink.js';
+
+vi.mock('./useResolvedUrl.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('./useResolvedUrl.js')>();
+    return {
+        ...actual,
+        useResolvedUrl: () => ({
+            url: 'https://example.test/artifact',
+            isLoading: false,
+            error: undefined,
+            scheme: 'artifact' as const,
+            retry: vi.fn(),
+        }),
+    };
+});
+
+afterEach(cleanup);
+
+describe('MarkdownLink artifact navigation', () => {
+    it('opens a Markdown artifact in the host viewer', () => {
+        const onArtifactOpen = vi.fn();
+        render(
+            <MarkdownLink href="artifact:files/report.md" artifactRunId="run-1" onArtifactOpen={onArtifactOpen}>
+                Report
+            </MarkdownLink>,
+        );
+
+        fireEvent.click(screen.getByRole('link', { name: 'Report' }));
+
+        expect(onArtifactOpen).toHaveBeenCalledWith('files/report.md');
+    });
+
+    it('keeps modified clicks and non-Markdown artifacts as downloads', () => {
+        const onArtifactOpen = vi.fn();
+        const view = render(
+            <MarkdownLink href="artifact:files/report.md" artifactRunId="run-1" onArtifactOpen={onArtifactOpen}>
+                Report
+            </MarkdownLink>,
+        );
+
+        fireEvent.click(screen.getByRole('link', { name: 'Report' }), { metaKey: true });
+        expect(onArtifactOpen).not.toHaveBeenCalled();
+
+        view.rerender(
+            <MarkdownLink href="artifact:files/report.pdf" artifactRunId="run-1" onArtifactOpen={onArtifactOpen}>
+                Report PDF
+            </MarkdownLink>,
+        );
+        fireEvent.click(screen.getByRole('link', { name: 'Report PDF' }));
+
+        expect(onArtifactOpen).not.toHaveBeenCalled();
+    });
+});
+
+describe('MarkdownLink agent resources', () => {
+    const ExistingLink = ({ href, children, className }: MarkdownLinkProps) => (
+        <a href={href} className={className}>
+            {children}
+        </a>
+    );
+
+    it('routes a custom resource scheme through the host resolver', () => {
+        const resolver = vi.fn<AgentResourceResolver>(() => ({ kind: 'navigate', href: '/custom/interactions/int-1' }));
+        render(
+            <AgentResourceResolverProvider value={resolver}>
+                <MarkdownLink href="interaction:int-1" artifactRunId="run-1">
+                    Interaction
+                </MarkdownLink>
+            </AgentResourceResolverProvider>,
+        );
+
+        expect(screen.getByRole('link', { name: 'Interaction' }).getAttribute('href')).toBe(
+            '/custom/interactions/int-1',
+        );
+        expect(resolver).toHaveBeenCalledWith(
+            { type: 'interaction', id: 'int-1' },
+            { workflowRunId: 'run-1', source: 'markdown', rawHref: 'interaction:int-1' },
+        );
+    });
+
+    it('supports a host activation callback', () => {
+        const onActivate = vi.fn();
+        render(
+            <AgentResourceResolverProvider value={() => ({ kind: 'activate', onActivate })}>
+                <MarkdownLink href="store:doc-1">Document</MarkdownLink>
+            </AgentResourceResolverProvider>,
+        );
+
+        fireEvent.click(screen.getByRole('button', { name: 'Document' }));
+        expect(onActivate).toHaveBeenCalledOnce();
+    });
+
+    it('renders plain text when no host resolver is configured', () => {
+        render(<MarkdownLink href="collection:col-1">Collection</MarkdownLink>);
+
+        expect(screen.queryByRole('link')).toBeNull();
+        expect(screen.getByText('Collection').tagName).toBe('SPAN');
+    });
+
+    it('preserves the class name when delegating standard and resolved resource links', () => {
+        const resolver: AgentResourceResolver = () => ({ kind: 'navigate', href: '/custom/interactions/int-1' });
+        render(
+            <AgentResourceResolverProvider value={resolver}>
+                <MarkdownLink href="https://example.com" className="standard-link" ExistingLink={ExistingLink}>
+                    Standard
+                </MarkdownLink>
+                <MarkdownLink href="interaction:int-1" className="resource-link" ExistingLink={ExistingLink}>
+                    Resource
+                </MarkdownLink>
+            </AgentResourceResolverProvider>,
+        );
+
+        expect(screen.getByRole('link', { name: 'Standard' }).className).toBe('standard-link');
+        expect(screen.getByRole('link', { name: 'Resource' }).className).toBe('resource-link');
+    });
+});

package/src/widgets/markdown/MarkdownLink.tsx

@@ -1,7 +1,9 @@
+import { Button } from '@vertesia/ui/core';
 import type { Element } from 'hast';
 import type React from 'react';
+import { parseAgentResourceHref, useAgentResourceResolver } from './AgentResourceResolver';
 import { CodeBlockPlaceholder } from './CodeBlockPlaceholder';
-import { mapSchemeToRoute, parseUrlScheme, useResolvedUrl } from './useResolvedUrl';
+import { parseUrlScheme, useResolvedUrl } from './useResolvedUrl';
 
 export interface MarkdownLinkProps {
     node?: Element;
@@ -9,6 +11,8 @@ export interface MarkdownLinkProps {
     children?: React.ReactNode;
     className?: string;
     artifactRunId?: string;
+    /** Open a Markdown artifact in the host artifact viewer instead of downloading it. */
+    onArtifactOpen?: (path: string) => void;
     /** Existing link component to delegate to for standard URLs */
     ExistingLink?: React.ComponentType<MarkdownLinkProps>;
 }
@@ -23,51 +27,108 @@ export function MarkdownLink({
     children,
     className,
     artifactRunId,
+    onArtifactOpen,
     ExistingLink,
     ...rest
 }: MarkdownLinkProps) {
     const rawHref = href || '';
+    const resource = parseAgentResourceHref(rawHref);
+    if (resource) {
+        return (
+            <AgentResourceMarkdownLink
+                resource={resource}
+                rawHref={rawHref}
+                artifactRunId={artifactRunId}
+                className={className}
+                ExistingLink={ExistingLink}
+                rest={rest}
+            >
+                {children}
+            </AgentResourceMarkdownLink>
+        );
+    }
+
     const { scheme, path } = parseUrlScheme(rawHref);
 
-    // For schemes that map directly to routes (store:, document://, collection:)
-    const mappedRoute = mapSchemeToRoute(scheme, path);
-    if (mappedRoute) {
+    // For standard URLs, delegate to existing component or render directly
+    if (scheme === 'standard') {
         if (typeof ExistingLink === 'function') {
             return (
-                <ExistingLink node={node} href={mappedRoute} {...rest}>
+                <ExistingLink node={node} href={href} className={className} {...rest}>
                     {children}
                 </ExistingLink>
             );
         }
         return (
-            <a href={mappedRoute} {...rest} className={className} target="_blank" rel="noopener noreferrer">
+            <a href={href} {...rest} className={className} target="_blank" rel="noopener noreferrer">
                 {children}
             </a>
         );
     }
 
-    // For standard URLs, delegate to existing component or render directly
-    if (scheme === 'standard') {
+    // For artifact: and image: URLs, use the resolver
+    return (
+        <ResolvedLink
+            rawHref={rawHref}
+            artifactRunId={artifactRunId}
+            artifactPath={scheme === 'artifact' ? path : undefined}
+            onArtifactOpen={onArtifactOpen}
+            className={className}
+            rest={rest}
+        >
+            {children}
+        </ResolvedLink>
+    );
+}
+
+function AgentResourceMarkdownLink({
+    resource,
+    rawHref,
+    artifactRunId,
+    className,
+    children,
+    ExistingLink,
+    rest,
+}: {
+    resource: NonNullable<ReturnType<typeof parseAgentResourceHref>>;
+    rawHref: string;
+    artifactRunId?: string;
+    className?: string;
+    children?: React.ReactNode;
+    ExistingLink?: React.ComponentType<MarkdownLinkProps>;
+    rest: Record<string, unknown>;
+}) {
+    const resolve = useAgentResourceResolver();
+    const target = resolve(resource, {
+        workflowRunId: artifactRunId,
+        source: 'markdown',
+        rawHref,
+    });
+
+    if (target.kind === 'navigate') {
         if (typeof ExistingLink === 'function') {
             return (
-                <ExistingLink node={node} href={href} {...rest}>
+                <ExistingLink href={target.href} className={className} {...rest}>
                     {children}
                 </ExistingLink>
             );
         }
         return (
-            <a href={href} {...rest} className={className} target="_blank" rel="noopener noreferrer">
+            <a href={target.href} {...rest} className={className} target="_blank" rel="noopener noreferrer">
                 {children}
             </a>
         );
     }
 
-    // For artifact: and image: URLs, use the resolver
-    return (
-        <ResolvedLink rawHref={rawHref} artifactRunId={artifactRunId} className={className} rest={rest}>
-            {children}
-        </ResolvedLink>
-    );
+    if (target.kind === 'activate') {
+        return (
+            <Button variant="link" size="none" className={className} onClick={target.onActivate}>
+                {children}
+            </Button>
+        );
+    }
+
+    return <span className={className}>{children}</span>;
 }
 
 /**
@@ -76,12 +137,16 @@ export function MarkdownLink({
 function ResolvedLink({
     rawHref,
     artifactRunId,
+    artifactPath,
+    onArtifactOpen,
     className,
     children,
     rest,
 }: {
     rawHref: string;
     artifactRunId?: string;
+    artifactPath?: string;
+    onArtifactOpen?: (path: string) => void;
     className?: string;
     children?: React.ReactNode;
     rest: Record<string, unknown>;
@@ -109,7 +174,27 @@ function ResolvedLink({
     }
 
     return (
-        <a href={url || '#'} {...rest} className={className} target="_blank" rel="noopener noreferrer">
+        <a
+            href={url || '#'}
+            {...rest}
+            className={className}
+            target="_blank"
+            rel="noopener noreferrer"
+            onClick={(event) => {
+                if (
+                    artifactPath &&
+                    /\.md$/i.test(artifactPath) &&
+                    onArtifactOpen &&
+                    !event.metaKey &&
+                    !event.ctrlKey &&
+                    !event.shiftKey &&
+                    event.button === 0
+                ) {
+                    event.preventDefault();
+                    onArtifactOpen(artifactPath);
+                }
+            }}
+        >
             {children}
         </a>
     );

package/src/widgets/markdown/MarkdownRenderer.tsx

@@ -26,7 +26,20 @@ type MarkdownParent = { children?: unknown[] };
 type RemarkPluginList = NonNullable<React.ComponentProps<typeof Markdown>['remarkPlugins']>;
 
 // Custom URL schemes that we handle in our components
-const ALLOWED_CUSTOM_SCHEMES = ['artifact:', 'image:', 'store:', 'document:', 'document://', 'collection:'];
+const ALLOWED_CUSTOM_SCHEMES = [
+    'artifact:',
+    'image:',
+    'store:',
+    'document:',
+    'document://',
+    'collection:',
+    'interaction:',
+    'prompt:',
+    'agent:',
+    'workflow:',
+    'process:',
+    'run:',
+];
 
 /**
  * Custom URL transform that allows our custom schemes while using
@@ -66,6 +79,8 @@ export interface MarkdownRendererProps {
      * Optional workflow run id used to resolve shorthand artifact paths (e.g. artifact:out/result.csv)
      */
     artifactRunId?: string;
+    /** Open Markdown artifact links in a host-provided viewer instead of downloading them. */
+    onArtifactOpen?: (path: string) => void;
     /** Additional className for the markdown wrapper */
     className?: string;
     /** Additional className for code blocks */
@@ -80,6 +95,11 @@ export interface MarkdownRendererProps {
     onProposalSelect?: (optionId: string) => void;
     /** Callback when user submits free-form response to proposal */
     onProposalSubmit?: (response: string) => void;
+    /**
+     * Keep parser source positions aligned with `children` by skipping source-changing
+     * normalization. Editing surfaces use this when node offsets are part of an anchor.
+     */
+    preserveSourcePositions?: boolean;
 }
 
 // Create default handlers once, outside component
@@ -91,6 +111,7 @@ export function MarkdownRenderer({
     remarkPlugins = [],
     removeComments = true,
     artifactRunId,
+    onArtifactOpen,
     className,
     codeClassName,
     inlineCodeClassName,
@@ -98,11 +119,15 @@ export function MarkdownRenderer({
     imageClassName,
     onProposalSelect,
     onProposalSubmit,
+    preserveSourcePositions = false,
 }: MarkdownRendererProps) {
     const codeBlockRegistry = useCodeBlockRendererRegistry();
     const normalizedMarkdown = React.useMemo(
-        () => normalizeDirectives(normalizeCustomSchemeLinks(preprocessMathDelimiters(children))),
-        [children],
+        () =>
+            preserveSourcePositions
+                ? children
+                : normalizeDirectives(normalizeCustomSchemeLinks(preprocessMathDelimiters(children))),
+        [children, preserveSourcePositions],
     );
 
     // Remark plugins (markdown parsing)
@@ -218,6 +243,7 @@ export function MarkdownRenderer({
                     href={href}
                     className={linkClassName}
                     artifactRunId={artifactRunId}
+                    onArtifactOpen={onArtifactOpen}
                     ExistingLink={
                         typeof ExistingLink === 'function'
                             ? (ExistingLink as React.ComponentType<MarkdownLinkProps>)
@@ -272,6 +298,7 @@ export function MarkdownRenderer({
     }, [
         components,
         artifactRunId,
+        onArtifactOpen,
         codeBlockRegistry,
         codeClassName,
         inlineCodeClassName,

package/src/widgets/markdown/index.ts

@@ -1,8 +1,25 @@
+export {
+    type AgentResourceLinkReference,
+    type AgentResourceResolver,
+    AgentResourceResolverProvider,
+    type AgentResourceTarget,
+    parseAgentResourceHref,
+    type ResourceResolveContext,
+    useAgentResourceResolver,
+} from './AgentResourceResolver';
 export {
     ArtifactContentRenderer,
     type ArtifactContentRendererProps,
     type ExpandRenderType,
 } from './ArtifactContentRenderer';
+export {
+    ArtifactEditingSurface,
+    type ArtifactEditingSurfaceDocumentEdit,
+    type ArtifactEditingSurfaceProps,
+    type ArtifactSaveStatus,
+    applyArtifactRefreshChanges,
+    isArtifactRefreshEvent,
+} from './ArtifactEditingSurface';
 export {
     type CodeBlockHandlerContext,
     CodeBlockHandlerProvider,
@@ -20,6 +37,17 @@ export {
     useCodeBlockComponent,
     useCodeBlockRendererRegistry,
 } from './CodeBlockRendering';
+export {
+    applyMarkdownEditingChange,
+    CollaborativeMarkdownRenderer,
+    type CollaborativeMarkdownRendererProps,
+    createMarkdownBlockAnchor,
+    formatMarkdownEditingAction,
+    type MarkdownBlockAnchor,
+    type MarkdownBlockType,
+    type MarkdownEditingAction,
+    type MarkdownEditingResource,
+} from './CollaborativeMarkdownRenderer';
 export {
     ChartCodeBlockHandler,
     createDefaultCodeBlockHandlers,
@@ -33,13 +61,23 @@ export { MarkdownImage, type MarkdownImageProps } from './MarkdownImage';
 export { MarkdownLink, type MarkdownLinkProps } from './MarkdownLink';
 export { MarkdownRenderer, type MarkdownRendererProps } from './MarkdownRenderer';
 export { MermaidDiagram } from './MermaidDiagram';
+export {
+    createUnifiedLineDiff,
+    diffTextSegments,
+    diffWordSegments,
+    getTextLineChangeRegions,
+    rebaseTextChanges,
+    type TextDiffSegment,
+    type TextLineChangeRegion,
+    type TextRebaseResult,
+    type UnifiedLineDiffOptions,
+} from './textDiff';
 export {
     type ArtifactContentState,
     type UseArtifactContentOptions,
     useArtifactContent,
 } from './useArtifactContent';
 export {
-    mapSchemeToRoute,
     parseUrlScheme,
     type ResolvedUrlState,
     type UrlScheme,

package/src/widgets/markdown/normalizeCustomSchemeLinks.ts

@@ -1,9 +1,22 @@
-const CUSTOM_SCHEME_PREFIXES = ['artifact:', 'image:', 'store:', 'document://', 'collection:'];
+const CUSTOM_SCHEME_PREFIXES = [
+    'artifact:',
+    'image:',
+    'store:',
+    'document://',
+    'collection:',
+    'interaction:',
+    'prompt:',
+    'agent:',
+    'workflow:',
+    'process:',
+    'run:',
+];
 
 // Excludes `[` from the link-text and destination classes: a long run of `[` (or
 // `[](image:` groups) with no closing delimiter would otherwise be re-scanned at every
 // start position, giving polynomial backtracking (CodeQL js/polynomial-redos).
-const CUSTOM_LINK_REGEX = /(!?\[[^[\]\n]*\]\()((?:artifact:|image:|store:|document:\/\/|collection:)[^)[\n]+)(\))/g;
+const CUSTOM_LINK_REGEX =
+    /(!?\[[^[\]\n]*\]\()((?:artifact:|image:|store:|document:\/\/|collection:|interaction:|prompt:|agent:|workflow:|process:|run:)[^)[\n]+)(\))/g;
 const INLINE_CODE_REGEX = /`[^`\n]*`/g;
 const FENCED_CODE_BLOCK_REGEX = /(^|\n)(`{3,}|~{3,})[^\n]*\n[\s\S]*?\n\2(?=\n|$)/g;
 const LINK_TITLE_SUFFIX_REGEX = /\s+("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\([^)]*\))\s*$/;

package/src/widgets/markdown/textDiff.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it } from 'vitest';
+import {
+    createUnifiedLineDiff,
+    diffTextSegments,
+    diffWordSegments,
+    getTextLineChangeRegions,
+    rebaseTextChanges,
+    type TextDiffSegment,
+} from './textDiff.js';
+
+function joinByTypes(segments: TextDiffSegment[], types: TextDiffSegment['type'][]): string {
+    return segments
+        .filter((segment) => types.includes(segment.type))
+        .map((segment) => segment.text)
+        .join('');
+}
+
+describe('diffWordSegments', () => {
+    it('returns a single equal segment for identical texts', () => {
+        expect(diffWordSegments('same text', 'same text')).toEqual([{ type: 'equal', text: 'same text' }]);
+    });
+
+    it('marks an appended sentence as added', () => {
+        const before = 'Keep this paragraph unchanged.';
+        const after = 'Keep this paragraph unchanged. Session edit A.';
+
+        expect(diffWordSegments(before, after)).toEqual([
+            { type: 'equal', text: 'Keep this paragraph unchanged.' },
+            { type: 'added', text: ' Session edit A.' },
+        ]);
+    });
+
+    it('marks a replaced word with a removal and an addition', () => {
+        const segments = diffWordSegments('Keep the tone light.', 'Keep the tone formal.');
+
+        expect(segments).toEqual([
+            { type: 'equal', text: 'Keep the tone ' },
+            { type: 'removed', text: 'light.' },
+            { type: 'added', text: 'formal.' },
+        ]);
+    });
+
+    it('reconstructs both sides from the segments across multiline edits', () => {
+        const before = '- Preserve all sections.\n- Keep the tone light.\n- Ship it.';
+        const after = '- Preserve all sections.\n- Keep the tone light and clear.\n- Log every revision.\n- Ship it.';
+        const segments = diffWordSegments(before, after);
+
+        expect(joinByTypes(segments, ['equal', 'removed'])).toBe(before);
+        expect(joinByTypes(segments, ['equal', 'added'])).toBe(after);
+    });
+
+    it('handles a full replacement', () => {
+        expect(diffWordSegments('old', 'new')).toEqual([
+            { type: 'removed', text: 'old' },
+            { type: 'added', text: 'new' },
+        ]);
+    });
+
+    it('handles empty sides', () => {
+        expect(diffWordSegments('', 'added')).toEqual([{ type: 'added', text: 'added' }]);
+        expect(diffWordSegments('removed', '')).toEqual([{ type: 'removed', text: 'removed' }]);
+        expect(diffWordSegments('', '')).toEqual([]);
+    });
+});
+
+describe('diffTextSegments', () => {
+    it('keeps unchanged lines aligned across a document-scale changed middle', () => {
+        const preserved = Array.from({ length: 220 }, (_, index) => `Preserved line ${index}.`).join('\n');
+        const before = `# Release notes\nOpening before.\n${preserved}\nClosing before.`;
+        const after = `# Release notes\nOpening after.\n${preserved}\nClosing after.`;
+
+        const segments = diffTextSegments(before, after);
+
+        expect(joinByTypes(segments, ['equal', 'removed'])).toBe(before);
+        expect(joinByTypes(segments, ['equal', 'added'])).toBe(after);
+        expect(
+            segments.some((segment) => segment.type === 'equal' && segment.text.includes('Preserved line 100.')),
+        ).toBe(true);
+    });
+
+    it('returns distinct line regions separated by unchanged content', () => {
+        expect(getTextLineChangeRegions('One\nTwo\nThree', 'One\nChanged\nThree\nFour')).toEqual([
+            { startLine: 1, endLine: 1 },
+            { startLine: 3, endLine: 3 },
+        ]);
+    });
+});
+
+describe('createUnifiedLineDiff', () => {
+    const BEFORE = ['# Title', '', 'First paragraph.', '', '- one', '- two', '- three', '', 'Closing line.'].join('\n');
+
+    it('returns undefined for identical texts', () => {
+        expect(createUnifiedLineDiff(BEFORE, BEFORE)).toBeUndefined();
+    });
+
+    it('produces a hunk with context and correct markers for a line change', () => {
+        const after = BEFORE.replace('- two', '- two (updated)');
+        const diff = createUnifiedLineDiff(BEFORE, after, { context: 1 });
+        expect(diff).toBe(['@@ -5,3 +5,3 @@', ' - one', '-- two', '+- two (updated)', ' - three'].join('\n'));
+    });
+
+    it('merges nearby changes into one hunk and separates distant ones', () => {
+        const after = BEFORE.replace('# Title', '# New Title').replace('Closing line.', 'Closing line!');
+        const diff = createUnifiedLineDiff(BEFORE, after, { context: 1 });
+        const headers = diff?.split('\n').filter((line) => line.startsWith('@@'));
+        expect(headers).toHaveLength(2);
+    });
+
+    it('handles pure insertions and deletions', () => {
+        const inserted = createUnifiedLineDiff('a\nb', 'a\nnew\nb', { context: 0 });
+        expect(inserted).toBe('@@ -2,0 +2,1 @@\n+new');
+        const deleted = createUnifiedLineDiff('a\nold\nb', 'a\nb', { context: 0 });
+        expect(deleted).toBe('@@ -2,1 +2,0 @@\n-old');
+    });
+
+    it('returns undefined when the diff exceeds maxChars', () => {
+        const after = BEFORE.replace('First paragraph.', 'Rewritten paragraph.');
+        expect(createUnifiedLineDiff(BEFORE, after, { maxChars: 10 })).toBeUndefined();
+    });
+});
+
+describe('rebaseTextChanges', () => {
+    const BASE = ['# Brief', '', 'Overview.', '', '## Goals', '- First', '- Second', '', 'Closing.'].join('\n');
+
+    it('combines non-overlapping local and remote changes', () => {
+        const local = BASE.replace('- Second', '- Second (local)');
+        const remote = BASE.replace('Overview.', 'Overview updated remotely.');
+
+        expect(rebaseTextChanges(BASE, local, remote)).toEqual({
+            status: 'rebased',
+            content: remote.replace('- Second', '- Second (local)'),
+        });
+    });
+
+    it('returns the local version unchanged when the remote content did not change', () => {
+        const local = BASE.replace('Closing.', 'Local closing.');
+        expect(rebaseTextChanges(BASE, local, BASE)).toEqual({ status: 'rebased', content: local });
+    });
+
+    it('deduplicates an identical concurrent edit', () => {
+        const changed = BASE.replace('- First', '- First (shared)');
+        expect(rebaseTextChanges(BASE, changed, changed)).toEqual({ status: 'rebased', content: changed });
+    });
+
+    it('reports overlapping replacements as a conflict and preserves the local version', () => {
+        const local = BASE.replace('Overview.', 'Local overview.');
+        const remote = BASE.replace('Overview.', 'Remote overview.');
+        expect(rebaseTextChanges(BASE, local, remote)).toEqual({ status: 'conflict', content: local });
+    });
+
+    it('treats competing insertions at the same base position as a conflict', () => {
+        const local = BASE.replace('## Goals', 'Local note.\n\n## Goals');
+        const remote = BASE.replace('## Goals', 'Remote note.\n\n## Goals');
+        expect(rebaseTextChanges(BASE, local, remote)).toEqual({ status: 'conflict', content: local });
+    });
+});