sh3-core 0.7.5 → 0.8.0

package/dist/api.d.ts

@@ -14,9 +14,15 @@ export type { StateZones } from './state/zones.svelte';
 export type { EnvState } from './env/types';
 export type { App, AppManifest, SourceApp, SourceAppManifest, AppContext, } from './apps/types';
 export { listRegisteredApps, getActiveApp } from './apps/registry.svelte';
-export { launchApp, returnToHome } from './apps/lifecycle';
+export { launchApp, returnToHome, unregisterApp } from './apps/lifecycle';
 export { inspectActiveLayout, spliceIntoActiveLayout, dockIntoActiveLayout, focusTab, focusView, collapseChild, expandChild, closeTab, } from './layout/inspection';
 export type { DocumentHandle, DocumentHandleOptions, DocumentFormat, DocumentMeta, DocumentChange, AutosaveController, } from './documents/types';
+export type { SyncHandle, SyncScope, ManifestEntry, ApplyEntry, ApplyOpts, ApplyOutcome, ApplyBatchResult, ConflictPolicy, ConflictResolution, ConflictContext, JournalEntry, ChangePage, GrantRecord, } from './documents/sync/types';
+export { PERMISSION_DOCUMENTS_SYNC, ScopeNotGrantedError, ScopeRevokedError, TenantMismatchError, } from './documents/sync/types';
+export { createSyncRegistry } from './documents/sync/registry';
+export type { SyncRegistry } from './documents/sync/registry';
+export { default as SyncGrantPicker } from './documents/sync/components/SyncGrantPicker.svelte';
+export { default as DocumentSyncExplorer } from './documents/sync/components/DocumentSyncExplorer.svelte';
 export { registeredShards, activeShards } from './shards/activate.svelte';
 export type { RegistryIndex, PackageEntry, PackageVersion, RequiredDependency, InstalledPackage, InstallResult, PackageMeta, } from './registry/types';
 export type { ResolvedPackage } from './registry/client';
@@ -30,7 +36,10 @@ export declare const capabilities: {
     readonly hotInstall: boolean;
 };
 export type { ServerShard, ServerShardContext } from './server-shard/types';
-export type { Verb } from './verbs/types';
+export type { Verb, VerbContext, ShellApi } from './verbs/types';
+export type { Scrollback } from './shell-shard/scrollback.svelte';
+export type { SessionClient } from './shell-shard/session-client.svelte';
 export { listVerbs } from './shards/registry';
 export { VERSION } from './version';
+export declare const FRAMEWORK_SHARD_IDS: readonly string[];
 export { setTokenOverrides, clearTokenOverrides, getTokenOverrides, } from './theme';

package/dist/api.js

@@ -26,9 +26,13 @@ export { shell } from './shellRuntime.svelte';
 export { PERMISSION_STATE_MANAGE } from './state/types';
 // Host actions callable from inside views (shell home, status bar, etc.).
 export { listRegisteredApps, getActiveApp } from './apps/registry.svelte';
-export { launchApp, returnToHome } from './apps/lifecycle';
+export { launchApp, returnToHome, unregisterApp } from './apps/lifecycle';
 // Layout inspection / mutation for advanced shards (diagnostic, etc.).
 export { inspectActiveLayout, spliceIntoActiveLayout, dockIntoActiveLayout, focusTab, focusView, collapseChild, expandChild, closeTab, } from './layout/inspection';
+export { PERMISSION_DOCUMENTS_SYNC, ScopeNotGrantedError, ScopeRevokedError, TenantMismatchError, } from './documents/sync/types';
+export { createSyncRegistry } from './documents/sync/registry';
+export { default as SyncGrantPicker } from './documents/sync/components/SyncGrantPicker.svelte';
+export { default as DocumentSyncExplorer } from './documents/sync/components/DocumentSyncExplorer.svelte';
 // Shard introspection — read-only reactive maps exposing which shards are
 // known to the host and which are currently active. Intended for diagnostic
 // and tooling shards that need to visualize framework state. Phase 9
@@ -47,5 +51,13 @@ export const capabilities = {
 export { listVerbs } from './shards/registry';
 // Package version.
 export { VERSION } from './version';
+// Framework shard IDs — shards that are always present (built-in to sh3-core).
+// Used by the store UI to skip dependency checks for these well-known shards.
+export const FRAMEWORK_SHARD_IDS = [
+    '__sh3core__',
+    'shell',
+    'sh3-store',
+    'sh3-admin',
+];
 // Theme token override API (shell-level theming support).
 export { setTokenOverrides, clearTokenOverrides, getTokenOverrides, } from './theme';

package/dist/app/store/StoreView.svelte

@@ -13,6 +13,7 @@
   import { contract } from '../../contract';
   import type { ResolvedPackage } from '../../registry/client';
   import type { InstalledPackage } from '../../registry/types';
+  import { FRAMEWORK_SHARD_IDS } from '../../api';
 
   let search = $state('');
   let typeFilter = $state<'all' | 'shard' | 'app'>('all');
@@ -75,6 +76,16 @@
     return ctx.state.ephemeral.installed.find((p: InstalledPackage) => p.id === id)?.version ?? '';
   }
 
+  function missingShards(pkg: ResolvedPackage, installed: InstalledPackage[]): string[] {
+    const required = pkg.latest.requires?.map((r) => r.id) ?? [];
+    if (required.length === 0) return [];
+    const known = new Set<string>(FRAMEWORK_SHARD_IDS);
+    for (const p of installed) {
+      if (p.type === 'shard' || p.type === 'combo') known.add(p.id);
+    }
+    return required.filter((id: string) => !known.has(id));
+  }
+
   async function handleUpdate(id: string) {
     if (updatingIds.has(id)) return;
 
@@ -118,6 +129,7 @@
         version: meta.version,
         contractVersion: meta.contractVersion,
         sourceRegistry: meta.sourceRegistry,
+        requiredShards: pkg.latest.requires?.map((r) => r.id) ?? [],
         installedAt: new Date().toISOString(),
       };
       const serverResult = await serverInstallPackage(manifest, bundle, serverBundle);
@@ -215,6 +227,7 @@
       {@const installing = installingIds.has(pkg.entry.id)}
       {@const updatable = hasUpdate(pkg.entry.id)}
       {@const updating = updatingIds.has(pkg.entry.id)}
+      {@const missing = missingShards(pkg, ctx.state.ephemeral.installed)}
       <div class="store-card">
         <div class="store-card-header">
           <div class="store-card-icon">
@@ -253,13 +266,19 @@
           {:else if installed}
             <span class="store-installed-label">Installed</span>
           {:else}
-            <button
-              class="store-install-btn"
-              onclick={() => handleInstall(pkg)}
-              disabled={installing}
-            >
-              {installing ? 'Installing...' : 'Install'}
-            </button>
+            <div class="store-install-wrap">
+              <button
+                class="store-install-btn"
+                onclick={() => handleInstall(pkg)}
+                disabled={installing || missing.length > 0}
+                title={missing.length > 0 ? `Missing required shards: ${missing.join(', ')}` : undefined}
+              >
+                {installing ? 'Installing...' : 'Install'}
+              </button>
+              {#if missing.length > 0}
+                <span class="store-card-missing">requires: {missing.join(', ')}</span>
+              {/if}
+            </div>
           {/if}
         </div>
       </div>
@@ -449,6 +468,16 @@
     color: var(--shell-success, #4caf50);
     font-weight: 600;
   }
+  .store-install-wrap {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+    gap: 4px;
+  }
+  .store-card-missing {
+    font-size: 0.75rem;
+    color: var(--shell-warning, #ff9800);
+  }
   .store-update-btn {
     padding: 5px 14px;
     background: var(--shell-warning, #ff9800);

package/dist/app/store/storeShard.svelte.js

@@ -134,7 +134,7 @@ export const storeShard = {
             await ctx.envUpdate({ registries });
         }
         async function updatePackage(id) {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const catalogEntry = state.ephemeral.updatable[id];
             if (!catalogEntry)
                 return;
@@ -160,10 +160,16 @@ export const storeShard = {
                 contractVersion: meta.contractVersion,
                 sourceRegistry: meta.sourceRegistry,
                 installedAt: new Date().toISOString(),
+                requiredShards: (_b = (_a = catalogEntry.latest.requires) === null || _a === void 0 ? void 0 : _a.map((r) => r.id)) !== null && _b !== void 0 ? _b : [],
             };
             const serverResult = await serverInstallPackage(manifest, bundle, serverBundle);
             if (!serverResult.ok) {
-                throw new Error((_a = serverResult.error) !== null && _a !== void 0 ? _a : 'Server update failed');
+                let message = (_c = serverResult.error) !== null && _c !== void 0 ? _c : 'Server update failed';
+                if (serverResult.code === 'missing-shards' && serverResult.missing) {
+                    const ids = serverResult.missing.map((m) => m.id).join(', ');
+                    message = `missing required shard(s): ${ids}`;
+                }
+                throw new Error(message);
             }
             // 4. Install locally (overwrites IndexedDB + re-registers).
             const result = await installPackage(bundle, meta);
@@ -177,7 +183,7 @@ export const storeShard = {
                         console.warn(`[sh3-store] Rollback failed for "${id}":`, rollbackErr instanceof Error ? rollbackErr.message : rollbackErr);
                     }
                 }
-                throw new Error((_b = result.error) !== null && _b !== void 0 ? _b : 'Local install failed during update');
+                throw new Error((_d = result.error) !== null && _d !== void 0 ? _d : 'Local install failed during update');
             }
             await refreshInstalled();
         }

package/dist/app/store/verbs.js

@@ -19,7 +19,7 @@ export const installVerb = {
     name: 'install',
     summary: 'Install a package by id from the catalog.',
     async run(ctx, args) {
-        var _a;
+        var _a, _b, _c;
         const id = args[0];
         if (!id) {
             ctx.scrollback.push({
@@ -71,12 +71,18 @@ export const installVerb = {
                 contractVersion: meta.contractVersion,
                 sourceRegistry: meta.sourceRegistry,
                 installedAt: new Date().toISOString(),
+                requiredShards: (_b = (_a = pkg.latest.requires) === null || _a === void 0 ? void 0 : _a.map((r) => r.id)) !== null && _b !== void 0 ? _b : [],
             };
             const serverResult = await serverInstallPackage(manifest, bundle, serverBundle);
             if (!serverResult.ok) {
+                let text = `install failed: ${(_c = serverResult.error) !== null && _c !== void 0 ? _c : 'server error'}`;
+                if (serverResult.code === 'missing-shards' && serverResult.missing) {
+                    const ids = serverResult.missing.map((m) => m.id).join(', ');
+                    text = `install failed: missing required shard(s): ${ids}`;
+                }
                 ctx.scrollback.push({
                     kind: 'status',
-                    text: `install failed: ${(_a = serverResult.error) !== null && _a !== void 0 ? _a : 'server error'}`,
+                    text,
                     level: 'error',
                     ts: Date.now(),
                 });

package/dist/apps/lifecycle.d.ts

@@ -25,6 +25,17 @@ export declare function launchApp(id: string): Promise<void>;
  * @param id - The `AppManifest.id` of the app to unload.
  */
 export declare function unloadApp(id: string): void;
+/**
+ * Unregister an app and remove it from the registry.
+ *
+ * If the app is currently active, force-closes (android-style): calls
+ * `App.deactivate`, detaches the layout, and deactivates required shards,
+ * then clears the active-app pointer. Unlike `returnToHome` this does not
+ * run suspend hooks and cannot be cancelled.
+ *
+ * No-op if the id is not registered.
+ */
+export declare function unregisterApp(id: string): void;
 /**
  * Return to the shell home view without unloading the active app. The
  * app's shards stay running, its layout proxy stays attached with its

package/dist/apps/lifecycle.js

@@ -14,7 +14,7 @@
 import { createStateZones } from '../state/zones.svelte';
 import { activateShard, deactivateShard, getShardContext, registeredShards, } from '../shards/activate.svelte';
 import { attachApp, acquireAppSlotHolds, detachApp, switchToApp, switchToHome, } from '../layout/store.svelte';
-import { activeApp, getRegisteredApp } from './registry.svelte';
+import { activeApp, getRegisteredApp, registeredApps } from './registry.svelte';
 import { createZoneManager } from '../state/manage';
 import { PERMISSION_STATE_MANAGE } from '../state/types';
 // ---------- last-active-app user zone ------------------------------------
@@ -169,6 +169,26 @@ export function unloadApp(id) {
     activeApp.id = null;
     appContexts.delete(id);
 }
+// ---------- unregister -------------------------------------------------------
+/**
+ * Unregister an app and remove it from the registry.
+ *
+ * If the app is currently active, force-closes (android-style): calls
+ * `App.deactivate`, detaches the layout, and deactivates required shards,
+ * then clears the active-app pointer. Unlike `returnToHome` this does not
+ * run suspend hooks and cannot be cancelled.
+ *
+ * No-op if the id is not registered.
+ */
+export function unregisterApp(id) {
+    if (!registeredApps.has(id))
+        return;
+    if (activeApp.id === id) {
+        unloadApp(id);
+        writeLastApp(null);
+    }
+    registeredApps.delete(id);
+}
 // ---------- return to home -----------------------------------------------
 /**
  * Return to the shell home view without unloading the active app. The

package/dist/apps/lifecycle.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { resetFramework } from '../__test__/reset';
 import { makeApp, makeShard, makeAppManifest, makeShardManifest, makeTabsNode, makeTabEntry, makeSlotNode, makeTree, } from '../__test__/fixtures';
-import { launchApp, returnToHome } from './lifecycle';
+import { launchApp, returnToHome, unregisterApp } from './lifecycle';
 import { registerApp } from './registry.svelte';
 import { registerShard } from '../shards/activate.svelte';
 import { presetManager } from '../overlays/presets';
@@ -258,3 +258,52 @@ describe('presets — scenario B.5 post-launch switch re-renders', () => {
         expect(container.querySelector('[data-view-for="slot-one"]')).toBeNull();
     });
 });
+// ---------------------------------------------------------------------------
+// unregisterApp — android-style force-close + removal
+// ---------------------------------------------------------------------------
+describe('unregisterApp', () => {
+    beforeEach(resetFramework);
+    it('removes an inactive app from the registry', async () => {
+        const { registeredApps } = await import('./registry.svelte');
+        const app = makeApp({ manifest: makeAppManifest({ id: 'app-u1' }) });
+        registerApp(app);
+        expect(registeredApps.has('app-u1')).toBe(true);
+        unregisterApp('app-u1');
+        expect(registeredApps.has('app-u1')).toBe(false);
+    });
+    it('force-closes to home if the app being unregistered is active', async () => {
+        const { activeApp, registeredApps } = await import('./registry.svelte');
+        const shard = makeShard({ manifest: makeShardManifest({ id: 'shard-U' }) });
+        registerShard(shard);
+        const app = makeApp({
+            manifest: makeAppManifest({ id: 'app-u2', requiredShards: ['shard-U'] }),
+        });
+        registerApp(app);
+        await launchApp('app-u2');
+        expect(activeApp.id).toBe('app-u2');
+        unregisterApp('app-u2');
+        expect(activeApp.id).toBeNull();
+        expect(registeredApps.has('app-u2')).toBe(false);
+    });
+    it('is a no-op for unknown ids', async () => {
+        expect(() => unregisterApp('does-not-exist')).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// installPackage — evict-before-register (via registerLoadedBundle)
+// ---------------------------------------------------------------------------
+describe('installPackage evict-before-register (simulated via registerLoadedBundle)', () => {
+    beforeEach(resetFramework);
+    it('replaces an existing shard entry when a new version is registered', async () => {
+        var _a, _b;
+        const { registerLoadedBundle } = await import('../registry/register');
+        const { deactivateShard, registeredShards } = await import('../shards/activate.svelte');
+        const s1 = makeShard({ manifest: makeShardManifest({ id: 'S', version: '' }) });
+        registerLoadedBundle({ shards: [s1], apps: [] }, { version: '1.0.0', sourceRegistry: '', contractVersion: '1' });
+        expect((_a = registeredShards.get('S')) === null || _a === void 0 ? void 0 : _a.manifest.version).toBe('1.0.0');
+        deactivateShard('S');
+        const s2 = makeShard({ manifest: makeShardManifest({ id: 'S', version: '' }) });
+        registerLoadedBundle({ shards: [s2], apps: [] }, { version: '1.0.1', sourceRegistry: '', contractVersion: '1' });
+        expect((_b = registeredShards.get('S')) === null || _b === void 0 ? void 0 : _b.manifest.version).toBe('1.0.1');
+    });
+});

package/dist/apps/types.d.ts

@@ -39,8 +39,9 @@ export interface AppManifest {
     /**
      * Optional permissions this app requests beyond the default sandbox.
      * Declared in the manifest and surfaced to the user at install time
-     * by the store app. Currently recognized: `'state:manage'` — cross-
-     * shard zone access.
+     * by the store app. Currently recognized:
+     *   - 'state:manage' — cross-shard zone access.
+     *   - 'documents:sync' — cross-shard document sync API.
      */
     permissions?: string[];
 }
@@ -61,6 +62,10 @@ export interface AppContext {
      * Cross-shard zone management API. Only present when the app's
      * manifest declares the `'state:manage'` permission. Check with
      * `if (ctx.zones)` before use.
+     *
+     * Related permissions also recognized by the framework:
+     *   - 'documents:sync' — cross-shard document sync API (exposed on
+     *     shard contexts as `ctx.sync()`, not on app contexts).
      */
     zones?: ZoneManager;
 }

package/dist/createShell.d.ts

@@ -15,6 +15,8 @@ export interface ShellConfig {
         type: string;
         version: string;
         bundleUrl: string;
+        sourceRegistry?: string;
+        contractVersion?: string;
     }>;
     /** Mount target — CSS selector or element (defaults to '#app') */
     target?: string | HTMLElement;

package/dist/createShell.js

@@ -15,8 +15,10 @@ import { __setEnvServerUrl } from './env/index';
 import { __setTenantId } from './documents/config';
 import { initFromBoot } from './auth/index';
 import SignInWall from './auth/SignInWall.svelte';
+import { loadBundleModule } from './registry/loader';
+import { registerLoadedBundle } from './registry/register';
 export async function createShell(config) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const sUrl = (_a = config === null || config === void 0 ? void 0 : config.serverUrl) !== null && _a !== void 0 ? _a : '';
     // 1. Platform detection
     const platform = await resolvePlatform();
@@ -45,7 +47,7 @@ export async function createShell(config) {
                 bootConfig = await res.json();
             }
         }
-        catch (_d) {
+        catch (_f) {
             // Server unreachable — boot without auth (offline mode)
         }
     }
@@ -73,7 +75,6 @@ export async function createShell(config) {
     }
     // 5. Load server-discovered packages
     if ((_c = config === null || config === void 0 ? void 0 : config.discoveredPackages) === null || _c === void 0 ? void 0 : _c.length) {
-        const { loadBundleModule } = await import('./registry/loader');
         for (const pkg of config.discoveredPackages) {
             try {
                 const res = await fetch(pkg.bundleUrl);
@@ -83,10 +84,11 @@ export async function createShell(config) {
                 }
                 const bytes = await res.arrayBuffer();
                 const loaded = await loadBundleModule(bytes);
-                for (const s of loaded.shards)
-                    registerShard(s);
-                for (const a of loaded.apps)
-                    registerApp(a);
+                registerLoadedBundle(loaded, {
+                    version: pkg.version,
+                    sourceRegistry: (_d = pkg.sourceRegistry) !== null && _d !== void 0 ? _d : '',
+                    contractVersion: (_e = pkg.contractVersion) !== null && _e !== void 0 ? _e : '',
+                });
                 console.log(`[sh3] Loaded discovered package: ${pkg.id}`);
             }
             catch (err) {

package/dist/documents/handle.js

@@ -18,6 +18,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _AutosaveControllerImpl_instances, _AutosaveControllerImpl_handle, _AutosaveControllerImpl_path, _AutosaveControllerImpl_debounceMs, _AutosaveControllerImpl_pending, _AutosaveControllerImpl_timer, _AutosaveControllerImpl_dirty, _AutosaveControllerImpl_disposed, _AutosaveControllerImpl_scheduleFlush, _AutosaveControllerImpl_clearTimer;
 import { documentChanges } from './notifications';
+import { notifyJournal } from './journal-hook';
+import { hashContent } from './sync/hash';
 const DEFAULT_DEBOUNCE_MS = 1000;
 /**
  * Create a document handle scoped to a tenant, shard, and file filter.
@@ -53,10 +55,13 @@ export function createDocumentHandle(tenantId, shardId, backend, options) {
             const existed = await backend.exists(tenantId, shardId, path);
             await backend.write(tenantId, shardId, path, content);
             emitChange(existed ? 'update' : 'create', path);
+            const hash = await hashContent(content);
+            await notifyJournal({ shardId, path, op: 'upsert', hash });
         },
         async delete(path) {
             await backend.delete(tenantId, shardId, path);
             emitChange('delete', path);
+            await notifyJournal({ shardId, path, op: 'delete', hash: null });
         },
         async exists(path) {
             return backend.exists(tenantId, shardId, path);

package/dist/documents/index.d.ts

@@ -4,3 +4,4 @@ export { HttpDocumentBackend } from './http-backend';
 export { createDocumentHandle } from './handle';
 export { documentChanges } from './notifications';
 export { getTenantId, getDocumentBackend, __setTenantId, __setDocumentBackend, } from './config';
+export * from './sync';

package/dist/documents/index.js

@@ -6,3 +6,4 @@ export { HttpDocumentBackend } from './http-backend';
 export { createDocumentHandle } from './handle';
 export { documentChanges } from './notifications';
 export { getTenantId, getDocumentBackend, __setTenantId, __setDocumentBackend, } from './config';
+export * from './sync';

package/dist/documents/journal-hook.d.ts

@@ -0,0 +1,6 @@
+import type { JournalEntry } from './sync/types';
+type Appender = (entry: Omit<JournalEntry, 'seq' | 'ts'>) => Promise<void>;
+export declare function setJournalAppender(fn: Appender): void;
+export declare function clearJournalAppender(): void;
+export declare function notifyJournal(entry: Omit<JournalEntry, 'seq' | 'ts'>): Promise<void>;
+export {};

package/dist/documents/journal-hook.js

@@ -0,0 +1,16 @@
+/*
+ * Journal appender hook — lets the sync engine subscribe to regular
+ * shard writes/deletes without creating an import cycle between the
+ * document handle and the sync subsystem.
+ */
+let appender = null;
+export function setJournalAppender(fn) {
+    appender = fn;
+}
+export function clearJournalAppender() {
+    appender = null;
+}
+export async function notifyJournal(entry) {
+    if (appender)
+        await appender(entry);
+}

package/dist/documents/sync/activate-integration.test.d.ts

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

package/dist/documents/sync/activate-integration.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryDocumentBackend } from '../backends';
+import { __setDocumentBackend, __setTenantId } from '../config';
+import { __resetShardRegistryForTest, registerShard, activateShard } from '../../shards/activate.svelte';
+import { __resetSyncBundlesForTest } from './singleton';
+import { PERMISSION_DOCUMENTS_SYNC } from './types';
+describe('ctx.sync() gating', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __resetSyncBundlesForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-a');
+    });
+    it('is undefined without documents:sync permission', async () => {
+        let captured;
+        const shard = {
+            manifest: { id: 's-none', version: '0', views: [] },
+            activate: async (ctx) => { captured = ctx; },
+        };
+        registerShard(shard);
+        await activateShard('s-none');
+        expect(captured.sync).toBeUndefined();
+    });
+    it('is a function when documents:sync is declared', async () => {
+        let captured;
+        const shard = {
+            manifest: { id: 's-sync', version: '0', views: [], permissions: [PERMISSION_DOCUMENTS_SYNC] },
+            activate: async (ctx) => { captured = ctx; },
+        };
+        registerShard(shard);
+        await activateShard('s-sync');
+        expect(typeof captured.sync).toBe('function');
+        const h = captured.sync();
+        expect(h.connectorId).toBe('s-sync');
+        expect(await h.grantedScopes()).toEqual([]);
+    });
+});

package/dist/documents/sync/components/DocumentSyncExplorer.svelte

@@ -0,0 +1,99 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import SyncGrantPicker from './SyncGrantPicker.svelte';
+  import { createSyncRegistry, type SyncRegistry } from '../registry';
+  import { getDocumentBackend, getTenantId } from '../../config';
+  import type { GrantRecord, SyncScope, ConflictResolution } from '../types';
+
+  interface Props {
+    /** Optional connector-specific filter; if omitted, shows everything. */
+    connectorId?: string;
+    /** Shard IDs whose conflict artifacts should be listed. */
+    conflictShardIds?: string[];
+    /** Pending grant request, if any — embeds the picker when set. */
+    pendingRequest?: { connectorId: string; scope: SyncScope };
+  }
+
+  let { connectorId, conflictShardIds = [], pendingRequest }: Props = $props();
+
+  let registry: SyncRegistry | null = $state(null);
+  let grants: GrantRecord[] = $state([]);
+  let conflicts: ConflictResolution[] = $state([]);
+
+  async function refresh() {
+    if (!registry) return;
+    grants = await registry.list(connectorId);
+    const all: ConflictResolution[] = [];
+    for (const shardId of conflictShardIds) {
+      all.push(...await registry.listConflicts(shardId));
+    }
+    conflicts = all;
+  }
+
+  onMount(async () => {
+    registry = createSyncRegistry(getDocumentBackend(), getTenantId());
+    await refresh();
+  });
+
+  async function revoke(record: GrantRecord) {
+    if (!registry) return;
+    await registry.revoke(record.connectorId, record.scope);
+    await refresh();
+  }
+
+  function describeScope(s: SyncScope): string {
+    if (s.kind === 'tenant') return 'entire tenant';
+    if (s.kind === 'shard') return `shard:${s.shardId}`;
+    return `shard:${s.shardId}/${s.prefix}`;
+  }
+</script>
+
+<section class="document-sync-explorer" part="container">
+  <h2 part="title">Document Sync</h2>
+
+  {#if pendingRequest}
+    <SyncGrantPicker
+      connectorId={pendingRequest.connectorId}
+      scope={pendingRequest.scope}
+      onGranted={refresh}
+    />
+  {/if}
+
+  <h3 part="subtitle">Granted scopes</h3>
+  {#if grants.length === 0}
+    <p part="empty">No scopes granted yet.</p>
+  {:else}
+    <ul part="grants">
+      {#each grants as g}
+        <li>
+          <span part="grant-connector">{g.connectorId}</span>
+          <span part="grant-scope">{describeScope(g.scope)}</span>
+          <button type="button" onclick={() => revoke(g)} part="revoke">Revoke</button>
+        </li>
+      {/each}
+    </ul>
+  {/if}
+
+  <h3 part="subtitle">Conflicts</h3>
+  {#if conflicts.length === 0}
+    <p part="empty">No active conflicts.</p>
+  {:else}
+    <ul part="conflicts">
+      {#each conflicts as c}
+        <li>
+          <code part="conflict-path">{c.shardId}:{c.path}</code>
+          <small part="conflict-artifact">{c.conflictArtifactPath}</small>
+        </li>
+      {/each}
+    </ul>
+  {/if}
+</section>
+
+<style>
+  .document-sync-explorer {
+    display: grid;
+    gap: 0.75rem;
+  }
+  ul { list-style: none; padding: 0; margin: 0; }
+  li { display: flex; gap: 0.5rem; align-items: center; }
+</style>

package/dist/documents/sync/components/DocumentSyncExplorer.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { SyncScope } from '../types';
+interface Props {
+    /** Optional connector-specific filter; if omitted, shows everything. */
+    connectorId?: string;
+    /** Shard IDs whose conflict artifacts should be listed. */
+    conflictShardIds?: string[];
+    /** Pending grant request, if any — embeds the picker when set. */
+    pendingRequest?: {
+        connectorId: string;
+        scope: SyncScope;
+    };
+}
+declare const DocumentSyncExplorer: import("svelte").Component<Props, {}, "">;
+type DocumentSyncExplorer = ReturnType<typeof DocumentSyncExplorer>;
+export default DocumentSyncExplorer;