sh3-core 0.10.2 → 0.10.4

package/dist/conflicts/api.d.ts

@@ -0,0 +1,108 @@
+import type { ShardContext } from '../shards/types';
+export interface ConflictItem {
+    /** Caller-unique within the batch. */
+    id: string;
+    /** Shown in the left rail and detail header, e.g. "notes/meeting.md". */
+    label: string;
+    /** Default inferred from `extension`. 'custom' must be set by caller. */
+    kind?: 'text' | 'binary' | 'custom';
+    /** Hint for renderer selection, e.g. '.md'. Used for kind inference too. */
+    extension?: string;
+    /** >=1 branch. Doc-zone conflicts produce >=2. */
+    branches: ConflictBranch[];
+    /** Opaque caller payload; echoed back in output for tracking. */
+    meta?: Record<string, unknown>;
+}
+export interface ConflictBranch {
+    /** 'local' | peerId | any caller-defined label. */
+    origin: string;
+    version: number;
+    /** Epoch ms of the branch write. */
+    at: number;
+    /** Text content; absent for binary or not-yet-fetched. */
+    content?: string;
+    /** Used by oversized-text fallback in MetaOnlyRenderer. */
+    sizeBytes?: number;
+    /** Short hash display for binary branches. */
+    hashPreview?: string;
+}
+export interface ResolveOptions {
+    /** Modal title override; defaults to "Resolve conflict(s)". */
+    title?: string;
+    /**
+     * Comparator for "most recent"; default compares `at` descending.
+     * A throwing comparator degrades to the default — never crashes the batch.
+     */
+    mostRecentBy?: (a: ConflictBranch, b: ConflictBranch) => number;
+    /** Force the three-way prompt even for single-item batches. */
+    requirePrompt?: boolean;
+}
+export type ResolveOutcome = {
+    status: 'resolved';
+    choices: Array<{
+        itemId: string;
+        chosen: ConflictBranch;
+        meta?: Record<string, unknown>;
+    }>;
+    skipped: string[];
+} | {
+    status: 'cancelled';
+};
+export interface ResolveDocumentsInput {
+    /** Target shard. Cross-shard requires documents:read + documents:write. */
+    shardId: string;
+    /** Paths to resolve. Pre-filtered to actual conflicts inside the adapter. */
+    paths: string[];
+}
+export type DocsResolveOutcome = {
+    status: 'resolved';
+    resolved: Array<{
+        path: string;
+        chosen: ConflictBranch;
+        appliedVersion: number;
+    }>;
+    failed: Array<{
+        path: string;
+        error: string;
+    }>;
+    skipped: string[];
+} | {
+    status: 'cancelled';
+};
+/**
+ * Public contribution point id — shards register specialized renderers
+ * via `ctx.contributions.register(CONFLICT_RENDERER_POINT, descriptor)`.
+ * Convention is priority 10+ for contributions; built-ins register at
+ * priority 0 (fallback) and 1 (default text renderer).
+ */
+export declare const CONFLICT_RENDERER_POINT = "sh3-core.conflictRenderer";
+export interface ConflictRenderer {
+    /** Shard-prefixed unique id, e.g. 'sh3-editor.guml-conflict-renderer'. */
+    id: string;
+    /** Called on every candidate item; the highest-priority truthy one wins. */
+    appliesTo(item: ConflictItem): boolean;
+    /** Higher wins. Default fallback = 0, default text = 1, contributions ≥ 10. */
+    priority?: number;
+    /** Mount the renderer into the provided container; return an unmount. */
+    mount(container: HTMLElement, props: ConflictRendererProps): () => void;
+}
+export interface ConflictRendererProps {
+    item: ConflictItem;
+    /** The currently chosen branch origin; mirrors the parent's state. */
+    selectedOrigin: string;
+    /** Renderers call this to drive selection; parent re-renders with new value. */
+    onSelect(origin: string): void;
+}
+/** Thrown when the adapter is called cross-shard without the required permissions. */
+export declare class ConflictPermissionError extends Error {
+    constructor(message: string);
+}
+/** Thrown when the caller's shard deactivates while a conflict session is open. */
+export declare class ConflictSessionOrphanedError extends Error {
+    constructor();
+}
+/** Runtime shape of `shell.conflicts`. */
+export interface ConflictsApi {
+    resolve(items: ConflictItem[], opts?: ResolveOptions): Promise<ResolveOutcome>;
+    resolveDocuments(ctx: ShardContext, input: ResolveDocumentsInput, opts?: ResolveOptions): Promise<DocsResolveOutcome>;
+}

package/dist/conflicts/api.js

@@ -0,0 +1,33 @@
+/*
+ * Public types for the conflict manager view.
+ *
+ * `shell.conflicts` exposes two entry points:
+ *   - resolve(items, opts): generic primitive
+ *   - resolveDocuments(ctx, input, opts): doc-zone adapter
+ *
+ * Shards construct ConflictItem arrays themselves (generic path) or pass
+ * { shardId, paths } to the adapter (doc path). The doc-zone adapter
+ * layers on top of the generic primitive — the shell does not know about
+ * documents; the adapter does.
+ */
+/**
+ * Public contribution point id — shards register specialized renderers
+ * via `ctx.contributions.register(CONFLICT_RENDERER_POINT, descriptor)`.
+ * Convention is priority 10+ for contributions; built-ins register at
+ * priority 0 (fallback) and 1 (default text renderer).
+ */
+export const CONFLICT_RENDERER_POINT = 'sh3-core.conflictRenderer';
+/** Thrown when the adapter is called cross-shard without the required permissions. */
+export class ConflictPermissionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConflictPermissionError';
+    }
+}
+/** Thrown when the caller's shard deactivates while a conflict session is open. */
+export class ConflictSessionOrphanedError extends Error {
+    constructor() {
+        super('Caller shard deactivated while conflict session was active');
+        this.name = 'ConflictSessionOrphanedError';
+    }
+}

package/dist/conflicts/most-recent.d.ts

@@ -0,0 +1,3 @@
+import type { ConflictBranch } from './api';
+export declare function defaultMostRecentBy(a: ConflictBranch, b: ConflictBranch): number;
+export declare function pickMostRecent(branches: ConflictBranch[], cmp: (a: ConflictBranch, b: ConflictBranch) => number): ConflictBranch | null;

package/dist/conflicts/most-recent.js

@@ -0,0 +1,23 @@
+/*
+ * Default "most recent" comparator + pickMostRecent helper.
+ *
+ * Default rule: compare by ConflictBranch.at descending (newer wins).
+ * Callers can override via ResolveOptions.mostRecentBy; pickMostRecent
+ * wraps the comparator in a try/catch so a broken override degrades to
+ * the default instead of exploding the batch.
+ */
+export function defaultMostRecentBy(a, b) {
+    // Newer (higher `at`) should come first — negative when a is newer.
+    return b.at - a.at;
+}
+export function pickMostRecent(branches, cmp) {
+    if (branches.length === 0)
+        return null;
+    try {
+        return [...branches].sort(cmp)[0];
+    }
+    catch (err) {
+        console.warn('[sh3-core] mostRecentBy comparator threw; falling back to default', err);
+        return [...branches].sort(defaultMostRecentBy)[0];
+    }
+}

package/dist/conflicts/most-recent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/conflicts/most-recent.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { defaultMostRecentBy, pickMostRecent } from './most-recent';
+function branch(origin, at, version = 1) {
+    return { origin, at, version };
+}
+describe('defaultMostRecentBy', () => {
+    it('descending by `at` — newest first', () => {
+        const out = [branch('a', 100), branch('b', 200), branch('c', 150)]
+            .slice()
+            .sort(defaultMostRecentBy);
+        expect(out.map((b) => b.origin)).toEqual(['b', 'c', 'a']);
+    });
+    it('stable when `at` is equal — returns 0', () => {
+        expect(defaultMostRecentBy(branch('a', 100), branch('b', 100))).toBe(0);
+    });
+});
+describe('pickMostRecent', () => {
+    let warnSpy;
+    beforeEach(() => {
+        warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        warnSpy.mockRestore();
+    });
+    it('returns the first branch by comparator', () => {
+        const a = branch('a', 100);
+        const b = branch('b', 200);
+        expect(pickMostRecent([a, b], defaultMostRecentBy)).toBe(b);
+    });
+    it('tolerates a broken caller comparator by falling back to default', () => {
+        const boom = () => { throw new Error('boom'); };
+        const b = branch('b', 200);
+        const out = pickMostRecent([branch('a', 100), b], boom);
+        expect(out).toBe(b);
+        expect(warnSpy).toHaveBeenCalled();
+    });
+    it('returns null for empty input', () => {
+        expect(pickMostRecent([], defaultMostRecentBy)).toBeNull();
+    });
+    it('caller comparator can pick an arbitrary branch', () => {
+        var _a;
+        const cmp = (a, b) => a.origin === 'local' ? -1 : b.origin === 'local' ? 1 : 0;
+        expect((_a = pickMostRecent([branch('peer', 999), branch('local', 1)], cmp)) === null || _a === void 0 ? void 0 : _a.origin).toBe('local');
+    });
+});

package/dist/conflicts/renderer-registry.d.ts

@@ -0,0 +1,7 @@
+import type { ConflictItem, ConflictRenderer } from './api';
+export declare const TEXT_EXTENSIONS: readonly string[];
+export declare function inferKind(item: ConflictItem): 'text' | 'binary' | 'custom';
+export declare function registerBuiltInRenderer(r: ConflictRenderer): () => void;
+export declare function pickRenderer(item: ConflictItem, contributed?: ConflictRenderer[]): ConflictRenderer | null;
+/** Test-only helper. */
+export declare function _resetForTests(): void;

package/dist/conflicts/renderer-registry.js

@@ -0,0 +1,59 @@
+/*
+ * Renderer selection for the conflict manager view.
+ *
+ * Two registration surfaces:
+ *   - Built-in renderers (TextDiffRenderer, MetaOnlyRenderer) are
+ *     registered from within sh3-core at first `shell.conflicts` use via
+ *     ensureBuiltInRenderersRegistered().
+ *   - Contributed renderers arrive via the ctx.contributions runtime
+ *     under CONFLICT_RENDERER_POINT. The conflict modal reads the
+ *     current list from the contributions registry each render.
+ *
+ * Selection: among renderers whose appliesTo(item) is true, the highest
+ * priority wins. Built-in fallback is priority 0 (MetaOnly), built-in
+ * text is priority 1, contributed renderers typically >= 10.
+ *
+ * Renderer appliesTo is wrapped in try/catch; a throwing check excludes
+ * that renderer from the match set, never crashes the pick.
+ *
+ * _resetForTests() clears the built-in set between test runs.
+ */
+export const TEXT_EXTENSIONS = Object.freeze([
+    '.md', '.txt', '.json', '.guml', '.css', '.js', '.ts', '.tsx', '.jsx',
+    '.html', '.svg', '.csv', '.yaml', '.yml', '.xml', '.log', '.ini', '.toml',
+]);
+export function inferKind(item) {
+    if (item.kind)
+        return item.kind;
+    if (item.extension && TEXT_EXTENSIONS.includes(item.extension.toLowerCase())) {
+        return 'text';
+    }
+    return 'binary';
+}
+const builtIns = [];
+export function registerBuiltInRenderer(r) {
+    builtIns.push(r);
+    return () => {
+        const i = builtIns.indexOf(r);
+        if (i >= 0)
+            builtIns.splice(i, 1);
+    };
+}
+export function pickRenderer(item, contributed = []) {
+    var _a;
+    const candidates = [...builtIns, ...contributed]
+        .filter((r) => {
+        try {
+            return r.appliesTo(item);
+        }
+        catch (_a) {
+            return false;
+        }
+    })
+        .sort((a, b) => { var _a, _b; return ((_a = b.priority) !== null && _a !== void 0 ? _a : 0) - ((_b = a.priority) !== null && _b !== void 0 ? _b : 0); });
+    return (_a = candidates[0]) !== null && _a !== void 0 ? _a : null;
+}
+/** Test-only helper. */
+export function _resetForTests() {
+    builtIns.length = 0;
+}

package/dist/conflicts/renderer-registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/conflicts/renderer-registry.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { inferKind, TEXT_EXTENSIONS, pickRenderer, registerBuiltInRenderer, _resetForTests, } from './renderer-registry';
+function item(opts = {}) {
+    return Object.assign({ id: 'x', label: 'x', branches: [{ origin: 'local', version: 1, at: 1 }] }, opts);
+}
+describe('inferKind', () => {
+    for (const ext of ['.md', '.txt', '.json', '.guml', '.ts']) {
+        it(`recognises ${ext} as text`, () => {
+            expect(inferKind(item({ extension: ext }))).toBe('text');
+        });
+    }
+    it('unknown extension → binary', () => {
+        expect(inferKind(item({ extension: '.bin' }))).toBe('binary');
+    });
+    it('no extension → binary', () => {
+        expect(inferKind(item({}))).toBe('binary');
+    });
+    it('extension case-insensitive', () => {
+        expect(inferKind(item({ extension: '.MD' }))).toBe('text');
+    });
+    it('explicit kind wins over inference', () => {
+        expect(inferKind(item({ extension: '.md', kind: 'custom' }))).toBe('custom');
+        expect(inferKind(item({ extension: '.md', kind: 'binary' }))).toBe('binary');
+    });
+    it('TEXT_EXTENSIONS covers the canonical set', () => {
+        expect(TEXT_EXTENSIONS.includes('.md')).toBe(true);
+        expect(TEXT_EXTENSIONS.includes('.json')).toBe(true);
+        expect(TEXT_EXTENSIONS.includes('.guml')).toBe(true);
+    });
+});
+describe('pickRenderer', () => {
+    beforeEach(() => _resetForTests());
+    const noopMount = () => () => { };
+    it('picks the built-in text renderer for text items', () => {
+        var _a;
+        const textRenderer = {
+            id: 'sh3-core.text',
+            appliesTo: (it) => inferKind(it) === 'text',
+            priority: 1,
+            mount: noopMount,
+        };
+        const fallback = {
+            id: 'sh3-core.meta',
+            appliesTo: () => true,
+            priority: 0,
+            mount: noopMount,
+        };
+        registerBuiltInRenderer(textRenderer);
+        registerBuiltInRenderer(fallback);
+        expect((_a = pickRenderer(item({ extension: '.md' }))) === null || _a === void 0 ? void 0 : _a.id).toBe('sh3-core.text');
+    });
+    it('falls back to meta when text renderer declines', () => {
+        var _a;
+        const textRenderer = {
+            id: 'sh3-core.text',
+            appliesTo: (it) => inferKind(it) === 'text',
+            priority: 1,
+            mount: noopMount,
+        };
+        const fallback = {
+            id: 'sh3-core.meta',
+            appliesTo: () => true,
+            priority: 0,
+            mount: noopMount,
+        };
+        registerBuiltInRenderer(textRenderer);
+        registerBuiltInRenderer(fallback);
+        expect((_a = pickRenderer(item({ kind: 'binary' }))) === null || _a === void 0 ? void 0 : _a.id).toBe('sh3-core.meta');
+    });
+    it('a contribution with higher priority wins over built-ins', () => {
+        var _a;
+        const textRenderer = {
+            id: 'sh3-core.text',
+            appliesTo: (it) => inferKind(it) === 'text',
+            priority: 1,
+            mount: noopMount,
+        };
+        registerBuiltInRenderer(textRenderer);
+        const contributed = {
+            id: 'sh3-editor.guml',
+            appliesTo: (it) => it.extension === '.guml',
+            priority: 10,
+            mount: noopMount,
+        };
+        expect((_a = pickRenderer(item({ extension: '.guml' }), [contributed])) === null || _a === void 0 ? void 0 : _a.id).toBe('sh3-editor.guml');
+    });
+    it('contribution whose appliesTo returns false is ignored', () => {
+        var _a;
+        const textRenderer = {
+            id: 'sh3-core.text',
+            appliesTo: (it) => inferKind(it) === 'text',
+            priority: 1,
+            mount: noopMount,
+        };
+        registerBuiltInRenderer(textRenderer);
+        const contributed = {
+            id: 'sh3-editor.guml',
+            appliesTo: () => false,
+            priority: 999,
+            mount: noopMount,
+        };
+        expect((_a = pickRenderer(item({ extension: '.md' }), [contributed])) === null || _a === void 0 ? void 0 : _a.id).toBe('sh3-core.text');
+    });
+    it('a renderer that throws from appliesTo is excluded, not fatal', () => {
+        var _a;
+        const boom = {
+            id: 'bad.one',
+            appliesTo: () => { throw new Error('boom'); },
+            priority: 999,
+            mount: noopMount,
+        };
+        const fallback = {
+            id: 'sh3-core.meta',
+            appliesTo: () => true,
+            priority: 0,
+            mount: noopMount,
+        };
+        registerBuiltInRenderer(fallback);
+        expect((_a = pickRenderer(item({}), [boom])) === null || _a === void 0 ? void 0 : _a.id).toBe('sh3-core.meta');
+    });
+    it('no renderer matches → null', () => {
+        expect(pickRenderer(item({ extension: '.bin' }), [])).toBeNull();
+    });
+});

package/dist/conflicts/renderers/MetaOnlyRenderer.svelte

@@ -0,0 +1,73 @@
+<script lang="ts">
+  import type { ConflictItem } from '../api';
+
+  interface Props {
+    item: ConflictItem;
+    selectedOrigin: string;
+    onSelect: (origin: string) => void;
+  }
+  const { item, selectedOrigin, onSelect }: Props = $props();
+
+  function formatSize(n?: number): string {
+    if (typeof n !== 'number') return '—';
+    if (n < 1024) return `${n} B`;
+    if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KiB`;
+    return `${(n / (1024 * 1024)).toFixed(2)} MiB`;
+  }
+
+  function relTime(at: number): string {
+    const delta = Date.now() - at;
+    if (delta < 60_000) return 'just now';
+    if (delta < 3_600_000) return `${Math.floor(delta / 60_000)}m ago`;
+    if (delta < 86_400_000) return `${Math.floor(delta / 3_600_000)}h ago`;
+    return new Date(at).toLocaleString();
+  }
+</script>
+
+<div class="sh3-conflict-meta">
+  <div class="sh3-conflict-meta-note">
+    No preview available for this content. Pick the branch you want to keep.
+  </div>
+  <ul class="sh3-conflict-meta-list">
+    {#each item.branches as b (b.origin)}
+      <li class="sh3-conflict-meta-li">
+        <button
+          type="button"
+          class="sh3-conflict-meta-row"
+          class:selected={b.origin === selectedOrigin}
+          onclick={() => onSelect(b.origin)}
+        >
+          <div class="sh3-conflict-meta-origin">{b.origin}</div>
+          <div class="sh3-conflict-meta-detail">
+            v{b.version} · {relTime(b.at)} · {formatSize(b.sizeBytes)}
+            {#if b.hashPreview} · <code>{b.hashPreview}</code>{/if}
+          </div>
+        </button>
+      </li>
+    {/each}
+  </ul>
+</div>
+
+<style>
+  .sh3-conflict-meta { padding: 16px; display: flex; flex-direction: column; gap: 12px; }
+  .sh3-conflict-meta-note { color: var(--shell-fg-muted, #888); font-size: 0.875rem; font-style: italic; }
+  .sh3-conflict-meta-list { list-style: none; padding: 0; margin: 0; display: flex; flex-direction: column; gap: 8px; }
+  .sh3-conflict-meta-li { margin: 0; }
+  .sh3-conflict-meta-row {
+    width: 100%;
+    text-align: left;
+    padding: 10px 12px;
+    background: var(--shell-input-bg, #2a2a2a);
+    color: var(--shell-fg, #e0e0e0);
+    border: 1px solid var(--shell-border, #444);
+    border-radius: var(--shell-radius-sm);
+    cursor: pointer;
+    font: inherit;
+  }
+  .sh3-conflict-meta-row.selected {
+    border-color: var(--shell-accent, #007acc);
+    box-shadow: 0 0 0 2px var(--shell-focus-ring, rgba(0,122,204,0.3));
+  }
+  .sh3-conflict-meta-origin { font-weight: 600; font-size: 0.875rem; }
+  .sh3-conflict-meta-detail { color: var(--shell-fg-muted, #888); font-size: 0.75rem; margin-top: 2px; }
+</style>

package/dist/conflicts/renderers/MetaOnlyRenderer.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { ConflictItem } from '../api';
+interface Props {
+    item: ConflictItem;
+    selectedOrigin: string;
+    onSelect: (origin: string) => void;
+}
+declare const MetaOnlyRenderer: import("svelte").Component<Props, {}, "">;
+type MetaOnlyRenderer = ReturnType<typeof MetaOnlyRenderer>;
+export default MetaOnlyRenderer;

package/dist/conflicts/renderers/TextDiffRenderer.svelte

@@ -0,0 +1,154 @@
+<script lang="ts">
+  import type { ConflictItem } from '../api';
+
+  interface Props {
+    item: ConflictItem;
+    selectedOrigin: string;
+    onSelect: (origin: string) => void;
+  }
+  const { item, selectedOrigin, onSelect }: Props = $props();
+
+  // 3+ branch mode: user picks a "reference" branch to compare against.
+  let reference = $state<string>('');
+  $effect(() => {
+    if (!reference || !item.branches.find((b) => b.origin === reference)) {
+      reference = item.branches[0]?.origin ?? 'local';
+    }
+  });
+  const isDualMode = $derived(item.branches.length === 2);
+
+  const leftBranch = $derived(
+    isDualMode
+      ? item.branches[0]
+      : (item.branches.find((b) => b.origin === reference) ?? item.branches[0]),
+  );
+  const rightBranch = $derived(
+    isDualMode
+      ? item.branches[1]
+      : (item.branches.find((b) => b.origin === selectedOrigin) ?? item.branches[1] ?? item.branches[0]),
+  );
+
+  /** Line-level diff: matches lines at the same index; does not do LCS. */
+  function lineDiff(a: string, b: string): Array<{ kind: 'same' | 'left' | 'right'; text: string }> {
+    const al = (a ?? '').split(/\r?\n/);
+    const bl = (b ?? '').split(/\r?\n/);
+    const out: Array<{ kind: 'same' | 'left' | 'right'; text: string }> = [];
+    const max = Math.max(al.length, bl.length);
+    for (let i = 0; i < max; i++) {
+      const left = al[i];
+      const right = bl[i];
+      if (left === right) {
+        if (typeof left === 'string') out.push({ kind: 'same', text: left });
+      } else {
+        if (typeof left === 'string') out.push({ kind: 'left', text: left });
+        if (typeof right === 'string') out.push({ kind: 'right', text: right });
+      }
+    }
+    return out;
+  }
+
+  const diff = $derived.by(() => {
+    if (!leftBranch || !rightBranch) return [];
+    return lineDiff(leftBranch.content ?? '', rightBranch.content ?? '');
+  });
+  const diffCount = $derived(diff.filter((d) => d.kind !== 'same').length);
+</script>
+
+<div class="sh3-conflict-text">
+  {#if isDualMode && leftBranch && rightBranch}
+    <div class="sh3-conflict-text-dual">
+      <!-- svelte-ignore a11y_click_events_have_key_events -->
+      <div
+        class="sh3-conflict-text-pane"
+        class:selected={leftBranch.origin === selectedOrigin}
+        role="button"
+        tabindex="0"
+        onclick={() => onSelect(leftBranch.origin)}
+        onkeydown={(e) => { if (e.key === 'Enter' || e.key === ' ') onSelect(leftBranch.origin); }}
+      >
+        <header class="sh3-conflict-text-head">{leftBranch.origin} · v{leftBranch.version}</header>
+        <pre class="sh3-conflict-text-body"><code>{leftBranch.content ?? ''}</code></pre>
+      </div>
+      <!-- svelte-ignore a11y_click_events_have_key_events -->
+      <div
+        class="sh3-conflict-text-pane"
+        class:selected={rightBranch.origin === selectedOrigin}
+        role="button"
+        tabindex="0"
+        onclick={() => onSelect(rightBranch.origin)}
+        onkeydown={(e) => { if (e.key === 'Enter' || e.key === ' ') onSelect(rightBranch.origin); }}
+      >
+        <header class="sh3-conflict-text-head">{rightBranch.origin} · v{rightBranch.version}</header>
+        <pre class="sh3-conflict-text-body"><code>{rightBranch.content ?? ''}</code></pre>
+      </div>
+    </div>
+    <details class="sh3-conflict-text-diff">
+      <summary>Line diff ({diffCount} difference{diffCount === 1 ? '' : 's'})</summary>
+      <pre><code>{#each diff as d, i (i)}<span class={`diff-${d.kind}`}>{d.kind === 'same' ? '  ' : d.kind === 'left' ? '- ' : '+ '}{d.text}{'\n'}</span>{/each}</code></pre>
+    </details>
+  {:else}
+    <div class="sh3-conflict-text-tabs">
+      <div class="sh3-conflict-text-picker">
+        <label>
+          Reference:
+          <select bind:value={reference}>
+            {#each item.branches as b (b.origin)}
+              <option value={b.origin}>{b.origin}</option>
+            {/each}
+          </select>
+        </label>
+      </div>
+      <div class="sh3-conflict-text-tablist">
+        {#each item.branches as b (b.origin)}
+          <button
+            class="sh3-conflict-text-tab"
+            class:selected={b.origin === selectedOrigin}
+            onclick={() => onSelect(b.origin)}
+          >
+            {b.origin} · v{b.version}
+          </button>
+        {/each}
+      </div>
+      {#if rightBranch}
+        <pre class="sh3-conflict-text-body"><code>{rightBranch.content ?? ''}</code></pre>
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .sh3-conflict-text { display: flex; flex-direction: column; gap: 12px; padding: 12px; height: 100%; min-height: 0; }
+  .sh3-conflict-text-dual { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; min-height: 0; flex: 1; }
+  .sh3-conflict-text-pane {
+    display: flex; flex-direction: column; min-height: 0;
+    border: 1px solid var(--shell-border, #444);
+    border-radius: var(--shell-radius-sm);
+    background: var(--shell-input-bg, #2a2a2a);
+    cursor: pointer;
+  }
+  .sh3-conflict-text-pane.selected {
+    border-color: var(--shell-accent, #007acc);
+    box-shadow: 0 0 0 2px var(--shell-focus-ring, rgba(0,122,204,0.3));
+  }
+  .sh3-conflict-text-head { padding: 6px 10px; font-size: 0.75rem; color: var(--shell-fg-muted, #888); border-bottom: 1px solid var(--shell-border, #444); }
+  .sh3-conflict-text-body {
+    margin: 0; padding: 10px; flex: 1; overflow: auto;
+    font-family: var(--shell-font-mono, monospace); font-size: 0.8125rem;
+  }
+  .sh3-conflict-text-diff { margin-top: 8px; }
+  .sh3-conflict-text-diff pre { background: var(--shell-input-bg, #2a2a2a); padding: 8px; overflow: auto; max-height: 240px; }
+  :global(.diff-left)  { color: var(--shell-error, #e35); }
+  :global(.diff-right) { color: var(--shell-success, #3a3); }
+  :global(.diff-same)  { opacity: 0.7; }
+  .sh3-conflict-text-tabs { display: flex; flex-direction: column; gap: 8px; min-height: 0; flex: 1; }
+  .sh3-conflict-text-picker select {
+    background: var(--shell-input-bg, #2a2a2a); color: var(--shell-fg, #e0e0e0);
+    border: 1px solid var(--shell-border, #444); padding: 2px 6px;
+  }
+  .sh3-conflict-text-tablist { display: flex; gap: 4px; flex-wrap: wrap; }
+  .sh3-conflict-text-tab {
+    padding: 4px 10px; background: var(--shell-input-bg, #2a2a2a); border: 1px solid var(--shell-border, #444);
+    border-radius: var(--shell-radius-sm); color: var(--shell-fg, #e0e0e0); cursor: pointer; font-size: 0.8125rem;
+  }
+  .sh3-conflict-text-tab.selected { border-color: var(--shell-accent, #007acc); }
+</style>

package/dist/conflicts/renderers/TextDiffRenderer.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { ConflictItem } from '../api';
+interface Props {
+    item: ConflictItem;
+    selectedOrigin: string;
+    onSelect: (origin: string) => void;
+}
+declare const TextDiffRenderer: import("svelte").Component<Props, {}, "">;
+type TextDiffRenderer = ReturnType<typeof TextDiffRenderer>;
+export default TextDiffRenderer;

package/dist/conflicts/renderers/index.d.ts

@@ -0,0 +1,8 @@
+import type { ConflictRenderer } from '../api';
+/** Max size per branch before we degrade to MetaOnlyRenderer. */
+export declare const OVERSIZED_TEXT_LIMIT_BYTES = 1048576;
+export declare const textDiffRenderer: ConflictRenderer;
+export declare const metaOnlyRenderer: ConflictRenderer;
+export declare function ensureBuiltInRenderersRegistered(): void;
+/** Test-only: re-enable registration after _resetForTests(). */
+export declare function _resetBuiltInRegistrationFlag(): void;