sh3-core 0.21.2 → 0.22.1

package/dist/documents/handle.js

@@ -20,76 +20,100 @@ var _AutosaveControllerImpl_instances, _AutosaveControllerImpl_handle, _Autosave
 import { documentChanges } from './notifications';
 const DEFAULT_DEBOUNCE_MS = 1000;
 /**
- * Create a document handle scoped to a tenant, shard, and file filter.
- * The framework calls this from `ShardContext.documents()`.
+ * Create a document handle scoped to a tenant and namespace. The framework
+ * pre-mints one handle per shard at boot; the namespace resolves lazily on
+ * every operation via `getShardBinding(shardId) ?? shardId` so it follows
+ * the shard's currently-bound app without re-minting.
+ *
+ * Format moves from the handle to per-call (readText/writeText/readJson/
+ * writeJson/readBinary/writeBinary) — see ADR-027.
  */
-export function createDocumentHandle(tenantId, shardId, backend, options) {
+export function createDocumentHandle(tenantId, shardOrNamespace, backend) {
     const controllers = new Set();
     const unsubscribers = new Set();
-    function matchesExtensions(path) {
-        if (!options.extensions || options.extensions.length === 0)
-            return true;
-        return options.extensions.some((ext) => path.endsWith(ext));
-    }
+    const resolveBoundTenant = typeof tenantId === 'function' ? tenantId : () => tenantId;
+    const resolveNamespace = typeof shardOrNamespace === 'function' ? shardOrNamespace : () => shardOrNamespace;
     function resolveTenant(opts) {
         var _a;
-        return (_a = opts === null || opts === void 0 ? void 0 : opts.scope) !== null && _a !== void 0 ? _a : tenantId;
+        return (_a = opts === null || opts === void 0 ? void 0 : opts.scope) !== null && _a !== void 0 ? _a : resolveBoundTenant();
     }
     function emitChange(type, path, tid) {
-        documentChanges.emit({ type, path, tenantId: tid, shardId });
+        documentChanges.emit({ type, path, tenantId: tid, shardId: resolveNamespace() });
     }
     const handle = {
         async list(opts) {
             const tid = resolveTenant(opts);
-            const all = await backend.list(tid, shardId);
-            if (!options.extensions || options.extensions.length === 0)
-                return all;
-            return all.filter((meta) => matchesExtensions(meta.path));
+            return backend.list(tid, resolveNamespace());
         },
-        async read(path, opts) {
-            const content = await backend.read(resolveTenant(opts), shardId, path);
+        async readText(path, opts) {
+            const content = await backend.read(resolveTenant(opts), resolveNamespace(), path);
             if (content === null)
                 return null;
-            // Phase 1: text format only. Binary returns as-is from the backend
-            // but the handle types it as string for text-format handles.
-            return typeof content === 'string' ? content : new TextDecoder().decode(content);
+            if (typeof content === 'string')
+                return content;
+            return new TextDecoder().decode(content);
+        },
+        async readBinary(path, opts) {
+            const content = await backend.read(resolveTenant(opts), resolveNamespace(), path);
+            if (content === null)
+                return null;
+            if (content instanceof ArrayBuffer)
+                return content;
+            return new TextEncoder().encode(content).buffer;
+        },
+        async readJson(path, opts) {
+            const text = await this.readText(path, opts);
+            if (text === null)
+                return null;
+            return JSON.parse(text);
         },
-        async write(path, content, opts) {
+        async writeText(path, content, opts) {
             const tid = resolveTenant(opts);
-            const existed = await backend.exists(tid, shardId, path);
-            await backend.write(tid, shardId, path, content);
+            const ns = resolveNamespace();
+            const existed = await backend.exists(tid, ns, path);
+            await backend.write(tid, ns, path, content);
             emitChange(existed ? 'update' : 'create', path, tid);
         },
+        async writeBinary(path, content, opts) {
+            const tid = resolveTenant(opts);
+            const ns = resolveNamespace();
+            const existed = await backend.exists(tid, ns, path);
+            await backend.write(tid, ns, path, content);
+            emitChange(existed ? 'update' : 'create', path, tid);
+        },
+        async writeJson(path, data, opts) {
+            await this.writeText(path, JSON.stringify(data), opts);
+        },
         async delete(path, opts) {
             const tid = resolveTenant(opts);
-            const existed = await backend.exists(tid, shardId, path);
-            await backend.delete(tid, shardId, path);
+            const ns = resolveNamespace();
+            const existed = await backend.exists(tid, ns, path);
+            await backend.delete(tid, ns, path);
             if (existed)
                 emitChange('delete', path, tid);
         },
         async rename(oldPath, newPath, opts) {
-            if (!matchesExtensions(newPath)) {
-                throw new Error(`Cannot rename to ${newPath}: violates handle extensions filter`);
-            }
             for (const ctrl of controllers) {
                 if (ctrl.path === oldPath) {
                     throw new Error(`Cannot rename: active autosave on ${oldPath}; flush and dispose first`);
                 }
             }
             const tid = resolveTenant(opts);
-            await backend.rename(tid, shardId, oldPath, newPath);
+            const ns = resolveNamespace();
+            await backend.rename(tid, ns, oldPath, newPath);
             documentChanges.emit({
                 type: 'rename',
                 path: newPath,
                 oldPath,
                 tenantId: tid,
-                shardId,
+                shardId: ns,
             });
         },
         async mkdir(path, opts) {
             const tid = resolveTenant(opts);
-            await backend.mkdir(tid, shardId, path);
-            documentChanges.emit({ type: 'folder-create', path, tenantId: tid, shardId });
+            const ns = resolveNamespace();
+            await backend.mkdir(tid, ns, path);
+            documentChanges.emit({ type: 'folder-create', path, tenantId: tid, shardId: ns });
         },
         async rmdir(path, opts) {
             var _a;
@@ -103,8 +127,9 @@ export function createDocumentHandle(tenantId, shardId, backend, options) {
                 }
             }
             const tid = resolveTenant(opts);
-            await backend.rmdir(tid, shardId, path, { recursive });
-            documentChanges.emit({ type: 'folder-delete', path, tenantId: tid, shardId });
+            const ns = resolveNamespace();
+            await backend.rmdir(tid, ns, path, { recursive });
+            documentChanges.emit({ type: 'folder-delete', path, tenantId: tid, shardId: ns });
         },
         async renameFolder(oldPath, newPath, opts) {
             const folderPrefix = oldPath + '/';
@@ -114,25 +139,26 @@ export function createDocumentHandle(tenantId, shardId, backend, options) {
                 }
             }
             const tid = resolveTenant(opts);
-            await backend.renameFolder(tid, shardId, oldPath, newPath);
+            const ns = resolveNamespace();
+            await backend.renameFolder(tid, ns, oldPath, newPath);
             documentChanges.emit({
                 type: 'folder-rename',
                 path: newPath,
                 oldPath,
                 tenantId: tid,
-                shardId,
+                shardId: ns,
             });
         },
         async listFolders(prefix, opts) {
-            return backend.listFolders(resolveTenant(opts), shardId, prefix !== null && prefix !== void 0 ? prefix : '');
+            return backend.listFolders(resolveTenant(opts), resolveNamespace(), prefix !== null && prefix !== void 0 ? prefix : '');
         },
         async exists(path) {
-            return backend.exists(tenantId, shardId, path);
+            return backend.exists(resolveBoundTenant(), resolveNamespace(), path);
         },
         async status(path) {
             if (!backend.readMeta)
                 throw new Error('Backend does not support status()');
-            return backend.readMeta(tenantId, shardId, path);
+            return backend.readMeta(resolveBoundTenant(), resolveNamespace(), path);
         },
         async resolveConflict(path, choice) {
             if (!backend.resolve)
@@ -140,21 +166,19 @@ export function createDocumentHandle(tenantId, shardId, backend, options) {
             if (typeof choice !== 'string' && !(typeof choice === 'object' && 'origin' in choice)) {
                 throw new Error('choice must be a string or { origin } object');
             }
-            return backend.resolve(tenantId, shardId, path, choice);
+            return backend.resolve(resolveBoundTenant(), resolveNamespace(), path, choice);
         },
         async readBranch(path, origin) {
             if (!backend.readBranch)
                 throw new Error('Backend does not support readBranch()');
-            return backend.readBranch(tenantId, shardId, path, origin);
+            return backend.readBranch(resolveBoundTenant(), resolveNamespace(), path, origin);
         },
         watch(callback) {
             // Subscribe to global emitter, filtered to this handle's scope.
             const unsub = documentChanges.subscribe((change) => {
-                if (change.tenantId !== tenantId)
-                    return;
-                if (change.shardId !== shardId)
+                if (change.tenantId !== resolveBoundTenant())
                     return;
-                if (!matchesExtensions(change.path))
+                if (change.shardId !== resolveNamespace())
                     return;
                 callback(change);
             });
@@ -221,7 +245,7 @@ class AutosaveControllerImpl {
             const content = __classPrivateFieldGet(this, _AutosaveControllerImpl_pending, "f");
             __classPrivateFieldSet(this, _AutosaveControllerImpl_pending, null, "f");
             __classPrivateFieldSet(this, _AutosaveControllerImpl_dirty, false, "f");
-            await __classPrivateFieldGet(this, _AutosaveControllerImpl_handle, "f").write(__classPrivateFieldGet(this, _AutosaveControllerImpl_path, "f"), content);
+            await __classPrivateFieldGet(this, _AutosaveControllerImpl_handle, "f").writeText(__classPrivateFieldGet(this, _AutosaveControllerImpl_path, "f"), content);
         }
     }
     async dispose() {

package/dist/documents/handle.test.js

@@ -4,7 +4,7 @@ import { createDocumentHandle } from './handle';
 import { documentChanges } from './notifications';
 function harness() {
     const backend = new MemoryDocumentBackend();
-    const handle = createDocumentHandle('tenant1', 'shard1', backend, { format: 'text' });
+    const handle = createDocumentHandle('tenant1', 'shard1', backend);
     return { backend, handle };
 }
 describe('DocumentHandle.status()', () => {
@@ -14,7 +14,7 @@ describe('DocumentHandle.status()', () => {
     });
     it('returns DocStatus after a write', async () => {
         const { handle } = harness();
-        await handle.write('a.txt', 'hi');
+        await handle.writeText('a.txt', 'hi');
         const s = await handle.status('a.txt');
         expect(s).toMatchObject({ exists: true, version: 1, syncState: 'synced' });
     });
@@ -33,7 +33,7 @@ describe('DocumentHandle.status()', () => {
             async renameFolder() { },
             async listFolders() { return []; },
         };
-        const handle = createDocumentHandle('t', 's', backend, { format: 'text' });
+        const handle = createDocumentHandle('t', 's', backend);
         await expect(handle.status('a.txt')).rejects.toThrow(/status/);
     });
 });
@@ -55,7 +55,7 @@ describe('DocumentHandle.resolveConflict()', () => {
             async renameFolder() { },
             async listFolders() { return []; },
         };
-        const handle = createDocumentHandle('tenant1', 'shard1', backend, { format: 'text' });
+        const handle = createDocumentHandle('tenant1', 'shard1', backend);
         await handle.resolveConflict('a.txt', 'local');
         expect(resolved).toEqual([{ t: 'tenant1', s: 'shard1', p: 'a.txt', c: 'local' }]);
     });
@@ -82,7 +82,7 @@ describe('DocumentHandle.readBranch()', () => {
             async renameFolder() { },
             async listFolders() { return []; },
         };
-        const handle = createDocumentHandle('tenant1', 'shard1', backend, { format: 'text' });
+        const handle = createDocumentHandle('tenant1', 'shard1', backend);
         const out = await handle.readBranch('a.txt', 'peer-1');
         expect(out).toBe('remote-content');
         expect(calls[0]).toEqual(['tenant1', 'shard1', 'a.txt', 'peer-1']);
@@ -103,7 +103,7 @@ describe('DocumentHandle.readBranch()', () => {
             async renameFolder() { },
             async listFolders() { return []; },
         };
-        const handle = createDocumentHandle('t', 's', backend, { format: 'text' });
+        const handle = createDocumentHandle('t', 's', backend);
         expect(await handle.readBranch('a.txt', 'peer-1')).toBeNull();
     });
     it('throws if the backend does not implement readBranch', async () => {
@@ -114,7 +114,7 @@ describe('DocumentHandle.readBranch()', () => {
 describe('DocumentHandle.rename', () => {
     it('moves the doc and emits one rename event', async () => {
         const { backend, handle } = harness();
-        await handle.write('old.txt', 'hello');
+        await handle.writeText('old.txt', 'hello');
         const events = [];
         const unsub = (await import('./notifications')).documentChanges.subscribe((c) => events.push(c));
         await handle.rename('old.txt', 'new.txt');
@@ -131,7 +131,7 @@ describe('DocumentHandle.rename', () => {
     });
     it('throws when an autosave controller is active on oldPath', async () => {
         const { handle } = harness();
-        await handle.write('old.txt', 'v1');
+        await handle.writeText('old.txt', 'v1');
         const ctrl = handle.autosave('old.txt', { debounceMs: 10000 });
         ctrl.update('v2');
         await expect(handle.rename('old.txt', 'new.txt'))
@@ -140,23 +140,15 @@ describe('DocumentHandle.rename', () => {
     });
     it('does not throw when an autosave controller exists for an unrelated path', async () => {
         const { handle } = harness();
-        await handle.write('old.txt', 'src');
-        await handle.write('other.txt', 'unrelated');
+        await handle.writeText('old.txt', 'src');
+        await handle.writeText('other.txt', 'unrelated');
         const ctrl = handle.autosave('other.txt', { debounceMs: 10000 });
         ctrl.update('still-unrelated');
         await expect(handle.rename('old.txt', 'new.txt')).resolves.toBeUndefined();
         await ctrl.dispose();
     });
-    it('throws when newPath violates the handle extensions filter', async () => {
-        const backend = new MemoryDocumentBackend();
-        const handle = createDocumentHandle('t1', 's1', backend, {
-            format: 'text',
-            extensions: ['.txt'],
-        });
-        await handle.write('a.txt', 'hi');
-        await expect(handle.rename('a.txt', 'a.md'))
-            .rejects.toThrow(/extensions/);
-    });
+    // v3: handle extensions filter is gone. Rename allows any path; per-format
+    // restrictions are now caller-side via the appropriate readX/writeX method.
 });
 describe('DocumentHandle.delete()', () => {
     it('emits a delete event when the path existed', async () => {
@@ -185,23 +177,23 @@ describe('DocumentHandle folder ops', () => {
     let handle;
     beforeEach(() => {
         backend = new MemoryDocumentBackend();
-        handle = createDocumentHandle('t', 's', backend, { format: 'text' });
+        handle = createDocumentHandle('t', 's', backend);
     });
     it('mkdir forwards to backend with bound tenant/shard', async () => {
         await handle.mkdir('a');
         expect(await backend.listFolders('t', 's', '')).toEqual(['a']);
     });
     it('rmdir defaults recursive to false', async () => {
-        await handle.write('a/x.md', 'x');
+        await handle.writeText('a/x.md', 'x');
         await expect(handle.rmdir('a')).rejects.toThrow();
     });
     it('rmdir({recursive:true}) cascades', async () => {
-        await handle.write('a/x.md', 'x');
+        await handle.writeText('a/x.md', 'x');
         await handle.rmdir('a', { recursive: true });
         expect(await handle.list()).toEqual([]);
     });
     it('renameFolder rewrites descendant paths', async () => {
-        await handle.write('old/x.md', 'x');
+        await handle.writeText('old/x.md', 'x');
         await handle.renameFolder('old', 'new');
         const docs = (await handle.list()).map((d) => d.path).sort();
         expect(docs).toEqual(['new/x.md']);
@@ -232,8 +224,8 @@ describe('DocumentHandle folder ops', () => {
         ]);
     });
     it('rmdir(recursive) emits a single folder-delete event', async () => {
-        await handle.write('a/x.md', 'x');
-        await handle.write('a/y.md', 'y');
+        await handle.writeText('a/x.md', 'x');
+        await handle.writeText('a/y.md', 'y');
         const events = [];
         handle.watch((c) => events.push(c));
         await handle.rmdir('a', { recursive: true });
@@ -242,7 +234,7 @@ describe('DocumentHandle folder ops', () => {
         ]);
     });
     it('renameFolder emits a single folder-rename event', async () => {
-        await handle.write('old/x.md', 'x');
+        await handle.writeText('old/x.md', 'x');
         const events = [];
         handle.watch((c) => events.push(c));
         await handle.renameFolder('old', 'new');
@@ -251,3 +243,83 @@ describe('DocumentHandle folder ops', () => {
         ]);
     });
 });
+describe('createDocumentHandle — namespace resolution', () => {
+    it('uses the shard/namespace string as the namespace root', async () => {
+        const backend = new MemoryDocumentBackend();
+        const handle = createDocumentHandle('tenant-1', 'sh3-editor', backend);
+        await handle.writeText('test.guml', 'content');
+        const keys = await backend.list('tenant-1', 'sh3-editor');
+        expect(keys.some((k) => k.path === 'test.guml')).toBe(true);
+    });
+});
+describe('createDocumentHandle — lazy resolvers', () => {
+    it('resolves namespace per operation from a function', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        let ns = 'shard-A';
+        const handle = createDocumentHandle('local', () => ns, backend);
+        await handle.writeText('foo.txt', 'first');
+        expect((await backend.list('local', 'shard-A')).map(d => d.path)).toContain('foo.txt');
+        ns = 'app-X';
+        await handle.writeText('bar.txt', 'second');
+        expect((await backend.list('local', 'app-X')).map(d => d.path)).toContain('bar.txt');
+        expect((await backend.list('local', 'shard-A')).map(d => d.path)).not.toContain('bar.txt');
+    });
+    it('resolves tenant per operation from a function', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        let tenant = 'alice';
+        const handle = createDocumentHandle(() => tenant, () => 'shard-A', backend);
+        await handle.writeText('p.txt', 'a');
+        expect((await backend.list('alice', 'shard-A')).map(d => d.path)).toContain('p.txt');
+        tenant = 'bob';
+        await handle.writeText('q.txt', 'b');
+        expect((await backend.list('bob', 'shard-A')).map(d => d.path)).toContain('q.txt');
+    });
+    it('watchers resolve namespace at emit time, not subscribe time', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        let ns = 'shard-A';
+        const handle = createDocumentHandle('local', () => ns, backend);
+        const seen = [];
+        handle.watch((c) => seen.push(`${c.type}:${c.path}`));
+        await handle.writeText('a.txt', 'x');
+        ns = 'app-X';
+        await handle.writeText('b.txt', 'y');
+        expect(seen).toContain('create:a.txt');
+        expect(seen).toContain('create:b.txt');
+    });
+    it('still accepts string tenant + namespace for back-compat', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        const handle = createDocumentHandle('local', 'shard-A', backend);
+        await handle.writeText('foo.txt', 'hi');
+        expect((await backend.list('local', 'shard-A')).map(d => d.path)).toContain('foo.txt');
+    });
+});
+describe('DocumentHandle — per-call format (v3)', () => {
+    let backend;
+    let handle;
+    beforeEach(() => {
+        backend = new MemoryDocumentBackend();
+        handle = createDocumentHandle(() => 'tenant-a', () => 'shard-a', backend);
+    });
+    it('readJson returns parsed object', async () => {
+        await handle.writeJson('config.json', { a: 1, b: 'two' });
+        expect(await handle.readJson('config.json')).toEqual({ a: 1, b: 'two' });
+    });
+    it('readJson returns null for missing doc', async () => {
+        expect(await handle.readJson('missing.json')).toBeNull();
+    });
+    it('readText round-trips', async () => {
+        await handle.writeText('note.md', 'hello');
+        expect(await handle.readText('note.md')).toBe('hello');
+    });
+    it('readBinary round-trips', async () => {
+        const data = new Uint8Array([1, 2, 3, 4]).buffer;
+        await handle.writeBinary('blob.bin', data);
+        const out = await handle.readBinary('blob.bin');
+        expect(out).not.toBeNull();
+        expect(new Uint8Array(out)).toEqual(new Uint8Array(data));
+    });
+});

package/dist/documents/index.d.ts

@@ -1,4 +1,4 @@
-export type { DocumentFormat, DocumentHandleOptions, DocumentMeta, DocumentChange, DocumentBackend, DocumentHandle, AutosaveController, ScopeOption, } from './types';
+export type { DocumentMeta, DocumentChange, DocumentBackend, DocumentHandle, AutosaveController, ScopeOption, } from './types';
 export { MemoryDocumentBackend, IndexedDBDocumentBackend } from './backends';
 export { HttpDocumentBackend } from './http-backend';
 export { createDocumentHandle } from './handle';

package/dist/documents/types.d.ts

@@ -36,21 +36,6 @@ export declare const PERMISSION_DOCUMENTS_READ = "documents:read";
 export declare const PERMISSION_DOCUMENTS_WRITE = "documents:write";
 /** Permission to manage document mount points (admin-only). */
 export declare const PERMISSION_DOCUMENTS_MOUNT = "documents:mount";
-/**
- * Format hint for document content. Determines whether reads return a string
- * (`text`) or an `ArrayBuffer` (`binary`).
- */
-export type DocumentFormat = 'text' | 'binary';
-/**
- * Options passed to `ctx.documents()` to scope the handle. The handle
- * only operates on files matching the declared extensions (if provided).
- * Omitting `extensions` means "all files."
- */
-export interface DocumentHandleOptions {
-    format: DocumentFormat;
-    /** File extensions this handle operates on, e.g. ['.guml', '.md']. */
-    extensions?: string[];
-}
 /** Metadata about a stored document. */
 export interface DocumentMeta {
     path: string;
@@ -219,12 +204,23 @@ export interface ScopeOption {
     scope?: string;
 }
 export interface DocumentHandle {
-    /** List documents matching the handle's extensions filter. */
+    /** List documents stored under this handle's namespace. */
     list(opts?: ScopeOption): Promise<DocumentMeta[]>;
-    /** Read a document by path. Returns null if not found. */
-    read(path: string, opts?: ScopeOption): Promise<string | null>;
-    /** Write (create or overwrite) a document. Explicit save. */
-    write(path: string, content: string, opts?: ScopeOption): Promise<void>;
+    /** Read a document as text. Returns null if not found. */
+    readText(path: string, opts?: ScopeOption): Promise<string | null>;
+    /** Read a document as a binary ArrayBuffer. Returns null if not found. */
+    readBinary(path: string, opts?: ScopeOption): Promise<ArrayBuffer | null>;
+    /**
+     * Read a document and JSON-parse it. Returns null if not found.
+     * Throws if the stored content is not valid JSON.
+     */
+    readJson<T = unknown>(path: string, opts?: ScopeOption): Promise<T | null>;
+    /** Write a string. */
+    writeText(path: string, content: string, opts?: ScopeOption): Promise<void>;
+    /** Write a binary ArrayBuffer. */
+    writeBinary(path: string, content: ArrayBuffer, opts?: ScopeOption): Promise<void>;
+    /** JSON-stringify and write. */
+    writeJson(path: string, data: unknown, opts?: ScopeOption): Promise<void>;
     /** Delete a document. */
     delete(path: string, opts?: ScopeOption): Promise<void>;
     /**

package/dist/host.d.ts

@@ -1,4 +1,4 @@
-import { registerShard as registerShardInternal } from './shards/activate.svelte';
+import { registerShard as registerShardInternal } from './shards/lifecycle.svelte';
 import { registerApp } from './apps/registry.svelte';
 import { __setBackend } from './state/zones.svelte';
 import { setLocalOwner } from './auth/index';

package/dist/host.js

@@ -15,8 +15,7 @@
  * import-hygiene rule is: shards and apps import from `api.ts`, the host
  * imports from `host.ts`.
  */
-import { registerShard as registerShardInternal, activateShard, registeredShards, } from './shards/activate.svelte';
-import { addAutostartShard } from './actions/state.svelte';
+import { registerShard as registerShardInternal, registerAllShards, } from './shards/lifecycle.svelte';
 import { registerApp, registeredApps } from './apps/registry.svelte';
 import { launchApp, readLastApp, clearLastApp } from './apps/lifecycle';
 import { sh3coreShard } from './sh3core-shard/sh3coreShard.svelte';
@@ -84,21 +83,9 @@ export async function bootstrap(config) {
     }
     // 3. Load any packages installed in a previous session from IndexedDB
     await loadInstalledPackages();
-    // 4. Activate every self-starting shard. Track them in the dispatcher's
-    // autostartShards set so the `'app'` action scope treats their actions as
-    // ambient (active even inside apps that don't list them as required).
-    for (const [id, shard] of registeredShards) {
-        if (shard.autostart) {
-            addAutostartShard(id);
-            try {
-                await activateShard(id, { phase: 'autostart' });
-            }
-            catch (_a) {
-                // Already logged + recorded in erroredShards by activateShard.
-                // One bad self-starting shard must not prevent the sh3 from booting.
-            }
-        }
-    }
+    // 4. v3: run register(ctx) on every registered shard. Lifecycle module
+    //    handles error isolation; one failing shard does not block boot.
+    await registerAllShards();
     // 5. Read the last-active app from the user zone. If auto-launch fails,
     // clear the slot so the next reload lands on home instead of looping
     // into the same failure. No toast — the user did not initiate this.
@@ -143,44 +130,10 @@ export async function bootstrapSatellite(config) {
     }
     // 3. Load any packages installed in a previous session from IndexedDB
     await loadInstalledPackages();
-    // 4. Autostart sweep — mirror host bootstrap. Every shard with an
-    //    `autostart` hook runs in satellites too: services (LLM providers),
-    //    ambient action hosts (`__sh3core__` provides the command palette
-    //    via `sh3.palette.open`), and any user-installed self-starter.
-    //    `addAutostartShard` keeps action scoping consistent with the host
-    //    so palette/global actions remain ambient inside `'app'` scope.
-    const autostartActivated = new Set();
-    for (const [id, shard] of registeredShards) {
-        if (shard.autostart) {
-            addAutostartShard(id);
-            try {
-                await activateShard(id, { phase: 'autostart' });
-                autostartActivated.add(id);
-            }
-            catch (_a) {
-                // Already logged + recorded in erroredShards by activateShard.
-                // One bad self-starting shard must not prevent the satellite from booting.
-            }
-        }
-    }
-    // 5. Activate explicit satellite shards (those carried by activateShards
-    //    in the payload — typically view-providing shards walked from the
-    //    layout). Skip ids already activated by the autostart sweep so the
-    //    diagnostic phase stays correct and we do no redundant work.
-    for (const id of config.activateShardIds) {
-        if (autostartActivated.has(id))
-            continue;
-        if (registeredShards.has(id)) {
-            try {
-                await activateShard(id, { phase: 'satellite' });
-            }
-            catch (err) {
-                console.error(`[sh3] satellite activation of "${id}" failed:`, err);
-            }
-        }
-        else {
-            console.warn(`[sh3] satellite requested shard "${id}" but it is not registered`);
-        }
-    }
+    // 4. v3: one-pass register sweep replaces the old autostart + satellite
+    //    passes. `config.activateShardIds` is now a no-op (the field is
+    //    retained on the interface for back-compat; Phase 6 deletes it).
+    void config;
+    await registerAllShards();
 }
 export { installPackage, listInstalledPackages } from './registry/installer';