sh3-core 0.22.0 → 0.22.2

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,20 +243,11 @@ describe('DocumentHandle folder ops', () => {
         ]);
     });
 });
-describe('createDocumentHandle — appId override', () => {
-    it('uses appId as the namespace root when provided', async () => {
-        const backend = new MemoryDocumentBackend();
-        const handle = createDocumentHandle('tenant-1', 'sh3-editor', backend, { format: 'text', appId: 'guml-ide' });
-        await handle.write('test.guml', 'content');
-        const keysAppId = await backend.list('tenant-1', 'guml-ide');
-        expect(keysAppId.some((k) => k.path === 'test.guml')).toBe(true);
-        const keysShardId = await backend.list('tenant-1', 'sh3-editor');
-        expect(keysShardId).toHaveLength(0);
-    });
-    it('falls back to shardId when appId is not provided', async () => {
+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, { format: 'text' });
-        await handle.write('test.guml', 'content');
+        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);
     });
@@ -274,11 +257,11 @@ describe('createDocumentHandle — lazy resolvers', () => {
         const { MemoryDocumentBackend } = await import('./backends');
         const backend = new MemoryDocumentBackend();
         let ns = 'shard-A';
-        const handle = createDocumentHandle('local', () => ns, backend, { format: 'text' });
-        await handle.write('foo.txt', 'first');
+        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.write('bar.txt', 'second');
+        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');
     });
@@ -286,31 +269,57 @@ describe('createDocumentHandle — lazy resolvers', () => {
         const { MemoryDocumentBackend } = await import('./backends');
         const backend = new MemoryDocumentBackend();
         let tenant = 'alice';
-        const handle = createDocumentHandle(() => tenant, () => 'shard-A', backend, { format: 'text' });
-        await handle.write('p.txt', 'a');
+        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.write('q.txt', 'b');
+        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, { format: 'text' });
+        const handle = createDocumentHandle('local', () => ns, backend);
         const seen = [];
         handle.watch((c) => seen.push(`${c.type}:${c.path}`));
-        await handle.write('a.txt', 'x');
+        await handle.writeText('a.txt', 'x');
         ns = 'app-X';
-        await handle.write('b.txt', 'y');
+        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, { format: 'text' });
-        await handle.write('foo.txt', 'hi');
+        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,27 +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[];
-    /**
-     * When set, this handle's namespace root becomes `{scope}/docs/{appId}/`
-     * instead of `{scope}/docs/{shardId}/`. Use in `onAppActivate` to get
-     * a handle scoped to the app's shared document namespace.
-     */
-    appId?: string;
-}
 /** Metadata about a stored document. */
 export interface DocumentMeta {
     path: string;
@@ -225,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';

package/dist/host.svelte.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { resetFramework } from './__test__/reset';
 import { makeShard, makeShardManifest } from './__test__/fixtures';
 import { bootstrapSatellite } from './host';
-import { registerShard, activeShards, erroredShards, } from './shards/activate.svelte';
+import { registerShard, activeShards, erroredShards, } from './shards/lifecycle.svelte';
 import { getLiveDispatcherState } from './actions/state.svelte';
 import { listActions } from './actions/registry';
 // loadInstalledPackages reads IndexedDB; neutralize it so the satellite
@@ -11,82 +11,50 @@ vi.mock('./registry/installer', async (orig) => {
     const real = await orig();
     return Object.assign(Object.assign({}, real), { loadInstalledPackages: vi.fn(async () => { }) });
 });
-describe('bootstrapSatellite — autostart sweep', () => {
+describe('bootstrapSatellite — v3 register sweep', () => {
     beforeEach(resetFramework);
-    it('activates a registered autostart shard even when not in activateShardIds', async () => {
-        const activate = vi.fn();
-        const autostart = vi.fn();
-        const svc = makeShard({
-            manifest: makeShardManifest({ id: 'svc-llm' }),
-            activate,
-            autostart,
-        });
-        registerShard(svc);
+    it('runs register() on every registered shard regardless of activateShardIds', async () => {
+        const registerA = vi.fn();
+        const registerB = vi.fn();
+        registerShard(makeShard({
+            manifest: makeShardManifest({ id: 'svc-a' }),
+            register: registerA,
+        }));
+        registerShard(makeShard({
+            manifest: makeShardManifest({ id: 'svc-b' }),
+            register: registerB,
+        }));
         await bootstrapSatellite({ activateShardIds: [] });
-        expect(activate).toHaveBeenCalledTimes(1);
-        expect(autostart).toHaveBeenCalledTimes(1);
-        expect(activeShards.has('svc-llm')).toBe(true);
+        expect(registerA).toHaveBeenCalledTimes(1);
+        expect(registerB).toHaveBeenCalledTimes(1);
+        expect(activeShards.has('svc-a')).toBe(true);
+        expect(activeShards.has('svc-b')).toBe(true);
     });
-    it('adds every activated autostart shard to the dispatcher autostart set', async () => {
-        const svc = makeShard({
-            manifest: makeShardManifest({ id: 'svc-llm' }),
-            autostart: () => { },
-        });
-        registerShard(svc);
-        await bootstrapSatellite({ activateShardIds: [] });
-        expect(getLiveDispatcherState().autostartShards.has('svc-llm')).toBe(true);
-    });
-    it('records a throwing autostart shard with phase "autostart" and continues activating the rest', async () => {
+    it('records a throwing register with phase "register" and continues activating the rest', async () => {
         var _a;
-        const goodActivate = vi.fn();
-        const bad = makeShard({
+        const goodRegister = vi.fn();
+        registerShard(makeShard({
             manifest: makeShardManifest({ id: 'svc-bad' }),
-            activate: () => {
-                throw new Error('boom');
-            },
-            autostart: () => { },
-        });
-        const good = makeShard({
+            register: () => { throw new Error('boom'); },
+        }));
+        registerShard(makeShard({
             manifest: makeShardManifest({ id: 'svc-good' }),
-            activate: goodActivate,
-            autostart: () => { },
-        });
-        registerShard(bad);
-        registerShard(good);
+            register: goodRegister,
+        }));
         await bootstrapSatellite({ activateShardIds: [] });
-        expect((_a = erroredShards.get('svc-bad')) === null || _a === void 0 ? void 0 : _a.phase).toBe('autostart');
+        expect((_a = erroredShards.get('svc-bad')) === null || _a === void 0 ? void 0 : _a.phase).toBe('register');
         expect(activeShards.has('svc-bad')).toBe(false);
-        expect(goodActivate).toHaveBeenCalledTimes(1);
+        expect(goodRegister).toHaveBeenCalledTimes(1);
         expect(activeShards.has('svc-good')).toBe(true);
     });
-    it('dedupes — an autostart shard listed in activateShardIds activates exactly once', async () => {
-        const activate = vi.fn();
-        const svc = makeShard({
-            manifest: makeShardManifest({ id: 'svc-llm' }),
-            activate,
-            autostart: () => { },
-        });
-        registerShard(svc);
-        await bootstrapSatellite({ activateShardIds: ['svc-llm'] });
-        expect(activate).toHaveBeenCalledTimes(1);
+    it('exposes getLiveDispatcherState without autostartShards', async () => {
+        await bootstrapSatellite({ activateShardIds: [] });
+        const state = getLiveDispatcherState();
+        expect('autostartShards' in state).toBe(false);
     });
     it('registers sh3.palette.open after bootstrapSatellite completes (palette reachable)', async () => {
         await bootstrapSatellite({ activateShardIds: [] });
         const ids = listActions().map((entry) => entry.action.id);
         expect(ids).toContain('sh3.palette.open');
     });
-    it('still activates non-autostart shards passed in activateShardIds with phase "satellite"', async () => {
-        var _a;
-        const activate = vi.fn(() => {
-            throw new Error('explicit-fail');
-        });
-        const view = makeShard({
-            manifest: makeShardManifest({ id: 'view-only' }),
-            activate,
-        });
-        registerShard(view);
-        await bootstrapSatellite({ activateShardIds: ['view-only'] });
-        expect(activate).toHaveBeenCalledTimes(1);
-        expect((_a = erroredShards.get('view-only')) === null || _a === void 0 ? void 0 : _a.phase).toBe('satellite');
-    });
 });

package/dist/layouts-shard/LayoutsSection.svelte

@@ -7,7 +7,7 @@
 
   import { getLayouts } from './layoutsState.svelte';
   import { restoreToFloat } from './layoutsApi';
-  import { listStandaloneViews } from '../shards/activate.svelte';
+  import { listStandaloneViews } from '../shards/lifecycle.svelte';
   import { toastManager } from '../overlays/toast';
   import { sh3 } from '../sh3Runtime.svelte';
   import { makeSelectionApi } from '../actions/selection.svelte';

package/dist/layouts-shard/layoutsShard.svelte.js

@@ -8,7 +8,7 @@
  * submenu and the home-page card grid.
  */
 import { VERSION } from '../version';
-import { listStandaloneViews } from '../shards/activate.svelte';
+import { listStandaloneViews } from '../shards/lifecycle.svelte';
 import { getSelection } from '../actions/selection.svelte';
 import { modalManager } from '../overlays/modal';
 import { toastManager } from '../overlays/toast';
@@ -137,7 +137,7 @@ export const layoutsShard = {
         version: VERSION,
         views: [],
     },
-    activate(ctx) {
+    register(ctx) {
         const zone = ctx.state({
             user: { layouts: [] },
         });
@@ -222,9 +222,6 @@ export const layoutsShard = {
             });
         });
     },
-    autostart() {
-        /* self-start so the action is available before any app launches. */
-    },
     deactivate() {
         __unbindZone();
     },

package/dist/layouts-shard/layoutsShard.svelte.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { registerShard, activateShard } from '../shards/activate.svelte';
+import { registerShard, activateShard } from '../shards/lifecycle.svelte';
 import { addAutostartShard } from '../actions/state.svelte';
 import { floatManager } from '../overlays/float';
 import { layoutsShard } from './layoutsShard.svelte';
@@ -15,7 +15,7 @@ const stubShard = {
         version: '0.0.0',
         views: [{ id: 'shell:terminal', label: 'Sh3', standalone: true }],
     },
-    activate(ctx) {
+    register(ctx) {
         ctx.registerView('shell:terminal', {
             mount: () => ({ unmount() { } }),
         });

package/dist/projects-shard/projectsShard.svelte.js

@@ -56,7 +56,7 @@ export const projectsShard = {
         version: VERSION,
         views: [{ id: PROJECTS_MANAGE_VIEW, label: 'Project Manager' }],
     },
-    activate(ctx) {
+    register(ctx) {
         void refreshProjects();
         if (typeof document !== 'undefined') {
             document.addEventListener('visibilitychange', () => {
@@ -141,8 +141,4 @@ export const projectsShard = {
             });
         });
     },
-    autostart() {
-        /* register on the self-starting path so the project list is available
-           on the home screen without an app launch. */
-    },
 };

package/dist/registry/installer.js

@@ -16,7 +16,7 @@
  */
 import { loadBundleModule } from './loader';
 import { savePackage, loadBundle, listInstalled, removePackage } from './storage';
-import { deactivateShard } from '../shards/activate.svelte';
+import { deactivateShard } from '../shards/lifecycle.svelte';
 import { unregisterApp } from '../apps/lifecycle';
 import { registerLoadedBundle } from './register';
 import { extractBundlePermissions } from './permission-descriptions';

package/dist/registry/loader.d.ts

@@ -37,7 +37,7 @@ export declare function loadBundleModule(bytes: ArrayBuffer): Promise<LoadedBund
 /**
  * Type guard: returns true if the loaded module is a shard.
  *
- * A shard has an `activate` function and `manifest.views` array. An app
+ * A shard has a `register` function and `manifest.views` array. An app
  * has neither — it has `initialLayout` and `manifest.requiredShards`.
  */
 export declare function isShard(mod: Shard | App): mod is Shard;

package/dist/registry/loader.js

@@ -125,12 +125,12 @@ export async function loadBundleModule(bytes) {
 /**
  * Type guard: returns true if the loaded module is a shard.
  *
- * A shard has an `activate` function and `manifest.views` array. An app
+ * A shard has a `register` function and `manifest.views` array. An app
  * has neither — it has `initialLayout` and `manifest.requiredShards`.
  */
 export function isShard(mod) {
-    return ('activate' in mod &&
-        typeof mod.activate === 'function' &&
+    return ('register' in mod &&
+        typeof mod.register === 'function' &&
         Array.isArray(mod.manifest.views));
 }
 /**