sh3-core 0.10.2 → 0.10.4

package/dist/conflicts/renderers/index.js

@@ -0,0 +1,63 @@
+/*
+ * Built-in renderer registration for the conflict manager view.
+ *
+ * Two renderers ship with sh3-core:
+ *   - TextDiffRenderer (priority 1) — text docs within OVERSIZED_TEXT_LIMIT_BYTES
+ *   - MetaOnlyRenderer (priority 0) — universal fallback (binary, oversized, unknown)
+ *
+ * Both use Svelte's `mount` / `unmount` to attach to the container the
+ * parent provides. They read props reactively; the parent owns
+ * selectedOrigin state and updates via the onSelect callback.
+ *
+ * ensureBuiltInRenderersRegistered() is idempotent; it's called from
+ * shell-api.ts on the first shell.conflicts use.
+ */
+import { mount, unmount } from 'svelte';
+import { inferKind, registerBuiltInRenderer } from '../renderer-registry';
+import TextDiffRenderer from './TextDiffRenderer.svelte';
+import MetaOnlyRenderer from './MetaOnlyRenderer.svelte';
+/** Max size per branch before we degrade to MetaOnlyRenderer. */
+export const OVERSIZED_TEXT_LIMIT_BYTES = 1048576; // 1 MiB
+function isOversized(sizeBytes) {
+    return typeof sizeBytes === 'number' && sizeBytes > OVERSIZED_TEXT_LIMIT_BYTES;
+}
+export const textDiffRenderer = {
+    id: 'sh3-core.text',
+    priority: 1,
+    appliesTo: (item) => {
+        if (inferKind(item) !== 'text')
+            return false;
+        return !item.branches.some((b) => isOversized(b.sizeBytes));
+    },
+    mount(container, props) {
+        const instance = mount(TextDiffRenderer, {
+            target: container,
+            props: props,
+        });
+        return () => { void unmount(instance); };
+    },
+};
+export const metaOnlyRenderer = {
+    id: 'sh3-core.meta',
+    priority: 0,
+    appliesTo: () => true,
+    mount(container, props) {
+        const instance = mount(MetaOnlyRenderer, {
+            target: container,
+            props: props,
+        });
+        return () => { void unmount(instance); };
+    },
+};
+let registered = false;
+export function ensureBuiltInRenderersRegistered() {
+    if (registered)
+        return;
+    registered = true;
+    registerBuiltInRenderer(textDiffRenderer);
+    registerBuiltInRenderer(metaOnlyRenderer);
+}
+/** Test-only: re-enable registration after _resetForTests(). */
+export function _resetBuiltInRegistrationFlag() {
+    registered = false;
+}

package/dist/conflicts/resolve-primitive.d.ts

@@ -0,0 +1,2 @@
+import { type ConflictItem, type ResolveOptions, type ResolveOutcome } from './api';
+export declare function resolvePrimitive(items: ConflictItem[], opts?: ResolveOptions): Promise<ResolveOutcome>;

package/dist/conflicts/resolve-primitive.js

@@ -0,0 +1,55 @@
+/*
+ * Generic conflict-resolve primitive — the modal machinery without the
+ * doc-zone adapter. Lives in its own file so `adapter-documents.ts` can
+ * import it statically without creating a cycle with the shell runtime.
+ */
+import { modalManager } from '../overlays/modal';
+import { list as listContributions } from '../contributions/registry';
+import { ensureBuiltInRenderersRegistered } from './renderers';
+import ConflictModal from './ConflictModal.svelte';
+import { defaultMostRecentBy } from './most-recent';
+import { CONFLICT_RENDERER_POINT, } from './api';
+function getContributedRenderers() {
+    try {
+        return listContributions(CONFLICT_RENDERER_POINT);
+    }
+    catch (_a) {
+        return [];
+    }
+}
+export function resolvePrimitive(items, opts = {}) {
+    ensureBuiltInRenderersRegistered();
+    if (items.length === 0) {
+        return Promise.resolve({ status: 'resolved', choices: [], skipped: [] });
+    }
+    return new Promise((settle) => {
+        var _a, _b, _c;
+        const title = (_a = opts.title) !== null && _a !== void 0 ? _a : (items.length === 1 ? 'Resolve conflict' : 'Resolve conflicts');
+        const mostRecentBy = (_b = opts.mostRecentBy) !== null && _b !== void 0 ? _b : defaultMostRecentBy;
+        const requirePrompt = (_c = opts.requirePrompt) !== null && _c !== void 0 ? _c : false;
+        const contributed = getContributedRenderers();
+        let settled = false;
+        const onResolve = (choices, skipped) => {
+            if (settled)
+                return;
+            settled = true;
+            settle({ status: 'resolved', choices, skipped });
+        };
+        const onCancel = () => {
+            if (settled)
+                return;
+            settled = true;
+            settle({ status: 'cancelled' });
+        };
+        const props = {
+            items,
+            title,
+            mostRecentBy,
+            requirePrompt,
+            contributed,
+            onResolve,
+            onCancel,
+        };
+        modalManager.open(ConflictModal, props, { boxStyle: 'max-width: none; min-width: 360px; padding: 0;' });
+    });
+}

package/dist/conflicts/shell-api.d.ts

@@ -0,0 +1,2 @@
+import type { ConflictsApi } from './api';
+export declare const conflictsApi: ConflictsApi;

package/dist/conflicts/shell-api.js

@@ -0,0 +1,13 @@
+/*
+ * shell.conflicts assembled API.
+ *
+ * The generic primitive lives in resolve-primitive.ts and the doc-zone
+ * adapter in adapter-documents.ts; this file just binds them together
+ * as the object exposed on the shell singleton.
+ */
+import { resolvePrimitive } from './resolve-primitive';
+import { resolveDocuments } from './adapter-documents';
+export const conflictsApi = {
+    resolve: resolvePrimitive,
+    resolveDocuments,
+};

package/dist/documents/browse.d.ts

@@ -1,4 +1,5 @@
 import type { DocumentBackend, DocumentChange, DocumentMeta } from './types';
+import type { DocStatus } from './sync-types';
 export interface BrowseCapability {
     /** Every document in the tenant across all shards, each tagged with its owning shardId. */
     listDocuments(): Promise<Array<DocumentMeta & {
@@ -32,6 +33,31 @@ export interface BrowseCapability {
      * `typeof ctx.browse.writeTo === 'function'`.
      */
     writeTo?(shardId: string, path: string, content: string | ArrayBuffer): Promise<void>;
+    /**
+     * Read sync-state metadata for any shard's document in the active
+     * tenant. Available only when the caller declares both
+     * `documents:browse` and `documents:read`. Returns null when the doc
+     * does not exist or the backend does not support status reads.
+     *
+     * Absent (undefined) on the capability object when `documents:read`
+     * is not declared.
+     */
+    statusFrom?(shardId: string, path: string): Promise<DocStatus | null>;
+    /**
+     * Read a single conflict branch's content for any shard's document in
+     * the active tenant. Gated identically to `statusFrom`. Returns null
+     * when the doc isn't in conflict, the origin isn't among branches, or
+     * the backend does not support branch reads.
+     */
+    readBranchFrom?(shardId: string, path: string, origin: string): Promise<string | null>;
+    /**
+     * Resolve a conflict on any shard's document in the active tenant.
+     * Available only when the caller declares both `documents:browse` and
+     * `documents:write`. Emits a `DocumentChange` update event on success.
+     */
+    resolveConflictFrom?(shardId: string, path: string, choice: 'local' | 'remote' | {
+        origin: string;
+    } | string): Promise<void>;
 }
 export interface BrowseCapabilityOptions {
     /** When true, the returned capability exposes `readFrom`. */

package/dist/documents/browse.js

@@ -18,6 +18,16 @@ export function createBrowseCapability(tenantId, backend, options = { canRead: f
     };
     if (options.canRead) {
         capability.readFrom = (shardId, path) => backend.read(tenantId, shardId, path);
+        capability.statusFrom = async (shardId, path) => {
+            if (!backend.readMeta)
+                return null;
+            return backend.readMeta(tenantId, shardId, path);
+        };
+        capability.readBranchFrom = async (shardId, path, origin) => {
+            if (!backend.readBranch)
+                return null;
+            return backend.readBranch(tenantId, shardId, path, origin);
+        };
     }
     if (options.canWrite) {
         capability.writeTo = async (shardId, path, content) => {
@@ -30,6 +40,12 @@ export function createBrowseCapability(tenantId, backend, options = { canRead: f
                 shardId,
             });
         };
+        capability.resolveConflictFrom = async (shardId, path, choice) => {
+            if (!backend.resolve)
+                throw new Error('Backend does not support resolveConflict');
+            await backend.resolve(tenantId, shardId, path, choice);
+            documentChanges.emit({ type: 'update', path, tenantId, shardId });
+        };
     }
     return capability;
 }

package/dist/documents/browse.test.js

@@ -119,4 +119,101 @@ describe('BrowseCapability', () => {
             expect(await browse.readFrom('shard-x', 'doc.txt')).toBe('roundtrip');
         });
     });
+    describe('statusFrom / readBranchFrom (documents:read gate)', () => {
+        it('absent when canRead is false', () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability('t1', be, { canRead: false, canWrite: false });
+            expect(browse.statusFrom).toBeUndefined();
+            expect(browse.readBranchFrom).toBeUndefined();
+        });
+        it('present when canRead is true', () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability('t1', be, { canRead: true, canWrite: false });
+            expect(typeof browse.statusFrom).toBe('function');
+            expect(typeof browse.readBranchFrom).toBe('function');
+        });
+        it('statusFrom delegates to backend.readMeta with tenant baked in', async () => {
+            const calls = [];
+            const be = {
+                read: vi.fn(),
+                write: vi.fn(),
+                delete: vi.fn(),
+                list: vi.fn(async () => []),
+                exists: vi.fn(async () => false),
+                listAllShards: vi.fn(async () => []),
+                listAllDocuments: vi.fn(async () => []),
+                readMeta: vi.fn(async (...args) => { calls.push(args); return null; }),
+            };
+            const browse = createBrowseCapability('t1', be, { canRead: true, canWrite: false });
+            await browse.statusFrom('other', 'a.txt');
+            expect(calls[0]).toEqual(['t1', 'other', 'a.txt']);
+        });
+        it('statusFrom returns null when backend has no readMeta', async () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability('t1', be, { canRead: true, canWrite: false });
+            expect(await browse.statusFrom('other', 'a.txt')).toBeNull();
+        });
+        it('readBranchFrom delegates to backend.readBranch with tenant baked in', async () => {
+            const calls = [];
+            const be = {
+                read: vi.fn(),
+                write: vi.fn(),
+                delete: vi.fn(),
+                list: vi.fn(async () => []),
+                exists: vi.fn(async () => false),
+                listAllShards: vi.fn(async () => []),
+                listAllDocuments: vi.fn(async () => []),
+                readBranch: vi.fn(async (...args) => { calls.push(args); return 'x'; }),
+            };
+            const browse = createBrowseCapability('t1', be, { canRead: true, canWrite: false });
+            const out = await browse.readBranchFrom('other', 'a.txt', 'peer-1');
+            expect(out).toBe('x');
+            expect(calls[0]).toEqual(['t1', 'other', 'a.txt', 'peer-1']);
+        });
+        it('readBranchFrom returns null when backend has no readBranch', async () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability('t1', be, { canRead: true, canWrite: false });
+            expect(await browse.readBranchFrom('other', 'a.txt', 'peer-1')).toBeNull();
+        });
+    });
+    describe('resolveConflictFrom (documents:write gate)', () => {
+        it('absent when canWrite is false', () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability('t1', be, { canRead: true, canWrite: false });
+            expect(browse.resolveConflictFrom).toBeUndefined();
+        });
+        it('present when canWrite is true', () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability('t1', be, { canRead: false, canWrite: true });
+            expect(typeof browse.resolveConflictFrom).toBe('function');
+        });
+        it('delegates to backend.resolve with tenant baked in and emits an update', async () => {
+            const calls = [];
+            const be = {
+                read: vi.fn(),
+                write: vi.fn(),
+                delete: vi.fn(),
+                list: vi.fn(async () => []),
+                exists: vi.fn(async () => false),
+                listAllShards: vi.fn(async () => []),
+                listAllDocuments: vi.fn(async () => []),
+                resolve: vi.fn(async (...args) => { calls.push(args); }),
+            };
+            const browse = createBrowseCapability('t1', be, { canRead: false, canWrite: true });
+            const events = [];
+            const unsub = documentChanges.subscribe((e) => events.push(e));
+            await browse.resolveConflictFrom('other', 'a.txt', { origin: 'peer-1' });
+            expect(calls[0]).toEqual(['t1', 'other', 'a.txt', { origin: 'peer-1' }]);
+            expect(events).toEqual([
+                { type: 'update', path: 'a.txt', tenantId: 't1', shardId: 'other' },
+            ]);
+            unsub();
+        });
+        it('throws if backend does not support resolve', async () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability('t1', be, { canRead: false, canWrite: true });
+            await expect(browse.resolveConflictFrom('other', 'a.txt', { origin: 'peer-1' }))
+                .rejects.toThrow(/does not support resolveConflict/);
+        });
+    });
 });

package/dist/documents/handle.js

@@ -74,6 +74,11 @@ export function createDocumentHandle(tenantId, shardId, backend, options) {
             }
             return backend.resolve(tenantId, shardId, path, choice);
         },
+        async readBranch(path, origin) {
+            if (!backend.readBranch)
+                throw new Error('Backend does not support readBranch()');
+            return backend.readBranch(tenantId, shardId, path, origin);
+        },
         watch(callback) {
             // Subscribe to global emitter, filtered to this handle's scope.
             const unsub = documentChanges.subscribe((change) => {

package/dist/documents/handle.test.js

@@ -53,3 +53,40 @@ describe('DocumentHandle.resolveConflict()', () => {
         await expect(handle.resolveConflict('a.txt', 'local')).rejects.toThrow(/resolveConflict/);
     });
 });
+describe('DocumentHandle.readBranch()', () => {
+    it('delegates to backend.readBranch with tenant + shard scope', async () => {
+        const calls = [];
+        const backend = {
+            async read() { return null; },
+            async write() { },
+            async delete() { },
+            async list() { return []; },
+            async exists() { return false; },
+            async listAllShards() { return []; },
+            async listAllDocuments() { return []; },
+            async readBranch(...args) { calls.push(args); return 'remote-content'; },
+        };
+        const handle = createDocumentHandle('tenant1', 'shard1', backend, { format: 'text' });
+        const out = await handle.readBranch('a.txt', 'peer-1');
+        expect(out).toBe('remote-content');
+        expect(calls[0]).toEqual(['tenant1', 'shard1', 'a.txt', 'peer-1']);
+    });
+    it('returns null when the backend returns null', async () => {
+        const backend = {
+            async read() { return null; },
+            async write() { },
+            async delete() { },
+            async list() { return []; },
+            async exists() { return false; },
+            async listAllShards() { return []; },
+            async listAllDocuments() { return []; },
+            async readBranch() { return null; },
+        };
+        const handle = createDocumentHandle('t', 's', backend, { format: 'text' });
+        expect(await handle.readBranch('a.txt', 'peer-1')).toBeNull();
+    });
+    it('throws if the backend does not implement readBranch', async () => {
+        const { handle } = harness();
+        await expect(handle.readBranch('a.txt', 'peer-1')).rejects.toThrow(/readBranch/);
+    });
+});

package/dist/documents/http-backend.d.ts

@@ -30,4 +30,5 @@ export declare class HttpDocumentBackend implements DocumentBackend {
     resolve(tenantId: string, shardId: string, path: string, choice: 'local' | 'remote' | {
         origin: string;
     } | string): Promise<void>;
+    readBranch(tenantId: string, shardId: string, path: string, origin: string): Promise<string | null>;
 }

package/dist/documents/http-backend.js

@@ -110,6 +110,15 @@ export class HttpDocumentBackend {
         if (!res.ok)
             throw new Error(`resolve failed: ${res.status}`);
     }
+    async readBranch(tenantId, shardId, path, origin) {
+        const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}/branch?origin=${encodeURIComponent(origin)}`;
+        const res = await fetch(url, { credentials: 'include' });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            throw new Error(`readBranch failed: ${res.status}`);
+        return res.text();
+    }
 }
 _HttpDocumentBackend_baseUrl = new WeakMap(), _HttpDocumentBackend_apiKey = new WeakMap(), _HttpDocumentBackend_instances = new WeakSet(), _HttpDocumentBackend_authHeaders = function _HttpDocumentBackend_authHeaders() {
     if (!__classPrivateFieldGet(this, _HttpDocumentBackend_apiKey, "f"))

package/dist/documents/http-backend.test.d.ts

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

package/dist/documents/http-backend.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { HttpDocumentBackend } from './http-backend';
+const originalFetch = globalThis.fetch;
+describe('HttpDocumentBackend.readBranch', () => {
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('GETs /branch?origin=... and returns text', async () => {
+        const calls = [];
+        globalThis.fetch = (async (url) => {
+            calls.push(String(url));
+            return new Response('remote', { status: 200 });
+        });
+        const be = new HttpDocumentBackend('http://x');
+        const out = await be.readBranch('t1', 'shard', 'a.txt', 'peer-1');
+        expect(out).toBe('remote');
+        expect(calls[0]).toContain('/api/docs/t1/shard/a.txt/branch?origin=peer-1');
+    });
+    it('returns null on 404', async () => {
+        globalThis.fetch = (async () => new Response(null, { status: 404 }));
+        const be = new HttpDocumentBackend('http://x');
+        expect(await be.readBranch('t1', 'shard', 'a.txt', 'peer-1')).toBeNull();
+    });
+    it('throws on non-404 error status', async () => {
+        globalThis.fetch = (async () => new Response('x', { status: 500 }));
+        const be = new HttpDocumentBackend('http://x');
+        await expect(be.readBranch('t1', 'shard', 'a.txt', 'peer-1')).rejects.toThrow();
+    });
+    it('URL-encodes the origin query parameter', async () => {
+        const calls = [];
+        globalThis.fetch = (async (url) => {
+            calls.push(String(url));
+            return new Response('x', { status: 200 });
+        });
+        const be = new HttpDocumentBackend('http://x');
+        await be.readBranch('t1', 'shard', 'a.txt', 'peer with space');
+        expect(calls[0]).toContain('origin=peer%20with%20space');
+    });
+});

package/dist/documents/types.d.ts

@@ -126,6 +126,13 @@ export interface DocumentBackend {
     resolve?(tenantId: string, shardId: string, path: string, choice: 'local' | 'remote' | {
         origin: string;
     } | string): Promise<void>;
+    /**
+     * Read the content of a specific conflict branch without committing it.
+     * Returns null if the doc is not in conflict state or the origin is not
+     * among the branches. Phase-1 text-only (matches `read` for text docs).
+     * Optional; only supported by HttpDocumentBackend in v1.
+     */
+    readBranch?(tenantId: string, shardId: string, path: string, origin: string): Promise<string | null>;
 }
 /**
  * Shard-facing document handle returned by `ctx.documents()`. Binds
@@ -151,6 +158,13 @@ export interface DocumentHandle {
     resolveConflict(path: string, choice: 'local' | 'remote' | {
         origin: string;
     } | string): Promise<void>;
+    /**
+     * Read the content of a specific conflict branch without committing it.
+     * Used by the conflict manager view to populate per-branch preview.
+     * Returns null if not in conflict or origin not among branches.
+     * Throws if the backend does not support branch reads.
+     */
+    readBranch(path: string, origin: string): Promise<string | null>;
     /**
      * Subscribe to change notifications within this handle's scope.
      * Returns an unsubscribe function.

package/dist/keys/ConsentDialog.svelte

@@ -56,6 +56,7 @@
       </dl>
       <div class="sh3-consent-actions">
         <!-- Deny has autofocus — safe default per spec -->
+        <!-- svelte-ignore a11y_autofocus -->
         <button type="button" class="sh3-consent-deny" onclick={deny} autofocus>Deny</button>
         <button type="button" class="sh3-consent-approve" onclick={approve}>Approve</button>
       </div>

package/dist/primitives/base.css

@@ -16,7 +16,7 @@ input[type="reset"],
 .shell-base-button {
   padding: 6px 14px;
   background: var(--shell-accent, #6ea8fe);
-  color: #fff;
+  color: var(--shell-fg, #fff);
   border: none;
   border-radius: var(--shell-radius);
   cursor: pointer;
@@ -40,3 +40,142 @@ input[type="reset"]:active,
 .shell-base-button:active {
   filter: brightness(0.92);
 }
+
+/* ── Text inputs ─────────────────────────────────────────────────────── */
+
+input[type="text"],
+input[type="email"],
+input[type="password"],
+input[type="search"],
+input[type="url"],
+input[type="tel"],
+input[type="number"],
+textarea,
+.shell-base-input {
+  padding: var(--shell-pad-md) var(--shell-pad-lg);
+  background: var(--shell-input-bg);
+  color: var(--shell-fg);
+  border: 1px solid var(--shell-border);
+  border-radius: var(--shell-radius);
+  font-family: inherit;
+  font-size: 0.8125rem;
+  line-height: var(--shell-line);
+}
+
+::placeholder { color: var(--shell-fg-muted); }
+
+input:focus-visible,
+textarea:focus-visible,
+.shell-base-input:focus-visible {
+  border-color: var(--shell-input-border-focus);
+  box-shadow: var(--shell-focus-ring);
+  outline: none;
+}
+
+input:disabled,
+textarea:disabled,
+.shell-base-input[aria-disabled="true"] {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+textarea {
+  resize: vertical;
+  min-height: calc(var(--shell-line) * 3em);
+}
+
+/* ── Checkbox & radio ────────────────────────────────────────────────── */
+
+input[type="checkbox"].shell-base-check,
+input[type="radio"].shell-base-radio {
+  appearance: none;
+  width: 14px;
+  height: 14px;
+  margin: 0;
+  background: var(--shell-input-bg);
+  border: 1px solid var(--shell-border);
+  cursor: pointer;
+  display: inline-grid;
+  place-content: center;
+  flex-shrink: 0;
+}
+
+.shell-base-check { border-radius: var(--shell-radius-sm); }
+.shell-base-radio { border-radius: 50%; }
+
+.shell-base-check:checked,
+.shell-base-radio:checked {
+  background: var(--shell-accent);
+  border-color: var(--shell-accent);
+}
+
+.shell-base-check:checked::before {
+  content: "";
+  width: 8px;
+  height: 8px;
+  background: #fff;
+  clip-path: polygon(14% 44%, 0 60%, 40% 100%, 100% 20%, 85% 8%, 38% 70%);
+}
+
+.shell-base-radio:checked::before {
+  content: "";
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: #fff;
+}
+
+.shell-base-check:focus-visible,
+.shell-base-radio:focus-visible {
+  box-shadow: var(--shell-focus-ring);
+  outline: none;
+}
+
+.shell-base-check:disabled,
+.shell-base-radio:disabled {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+/* ── Switch ──────────────────────────────────────────────────────────── */
+
+input[type="checkbox"].shell-base-switch {
+  appearance: none;
+  position: relative;
+  width: 28px;
+  height: 16px;
+  margin: 0;
+  background: var(--shell-border-strong);
+  border-radius: 999px;
+  cursor: pointer;
+  transition: background 120ms ease;
+  flex-shrink: 0;
+}
+
+.shell-base-switch::before {
+  content: "";
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  width: 12px;
+  height: 12px;
+  background: var(--shell-fg);
+  border-radius: 50%;
+  transition: transform 120ms ease;
+}
+
+.shell-base-switch:checked { background: var(--shell-accent); }
+.shell-base-switch:checked::before {
+  transform: translateX(12px);
+  background: #fff;
+}
+
+.shell-base-switch:focus-visible {
+  box-shadow: var(--shell-focus-ring);
+  outline: none;
+}
+
+.shell-base-switch:disabled {
+  opacity: 0.55;
+  cursor: not-allowed;
+}

package/dist/shell-shard/InputLine.svelte

@@ -119,6 +119,7 @@
   .shell-input-cwd { color: var(--shell-fg-muted, #888); }
   .shell-input-arrow { color: var(--shell-accent, #6cf); }
   .shell-input-field {
+    padding: 0;
     flex: 1 1 auto;
     background: transparent;
     border: 0;

package/dist/shellRuntime.svelte.d.ts

@@ -5,6 +5,7 @@ import { type PopupManager } from './overlays/popup';
 import { type ToastManager } from './overlays/toast';
 import { type FloatManager } from './overlays/float';
 import { type PresetManager } from './overlays/presets';
+import type { ConflictsApi } from './conflicts/api';
 /**
  * The process-wide shell singleton exposed to shards and the shell's own
  * internal code. Provides state zone creation and overlay managers.
@@ -28,6 +29,8 @@ export interface Shell {
     float: FloatManager;
     /** Named layout presets per app. See overlays/presets.ts. */
     presets: PresetManager;
+    /** Conflict manager view. Shell-owned modal for conflict arbitration. */
+    conflicts: ConflictsApi;
 }
 /** The process-wide shell instance. Framework-internal code uses this directly; shards receive a scoped view via `ShardContext`. */
 export declare const shell: Shell;

package/dist/shellRuntime.svelte.js

@@ -20,6 +20,7 @@ import { popupManager } from './overlays/popup';
 import { toastManager } from './overlays/toast';
 import { floatManager } from './overlays/float';
 import { presetManager } from './overlays/presets';
+import { conflictsApi } from './conflicts/shell-api';
 /** The process-wide shell instance. Framework-internal code uses this directly; shards receive a scoped view via `ShardContext`. */
 export const shell = {
     state: createStateZones,
@@ -28,4 +29,5 @@ export const shell = {
     toast: toastManager,
     float: floatManager,
     presets: presetManager,
+    conflicts: conflictsApi,
 };