sh3-core 0.6.0 → 0.7.1

package/dist/registry/schema.js

@@ -119,6 +119,10 @@ function validatePackageVersion(data, path) {
     if ('serverBundleUrl' in obj && obj.serverBundleUrl !== undefined) {
         requireString(obj, 'serverBundleUrl', path);
     }
+    // Optional server bundle integrity hash — provisional, see ADR-015.
+    if ('serverIntegrity' in obj && obj.serverIntegrity !== undefined) {
+        requireString(obj, 'serverIntegrity', path);
+    }
     let requires;
     if (obj['requires'] !== undefined) {
         if (!Array.isArray(obj['requires'])) {
@@ -132,6 +136,7 @@ function validatePackageVersion(data, path) {
         bundleUrl: obj['bundleUrl'],
         integrity: obj['integrity'],
         serverBundleUrl: typeof obj['serverBundleUrl'] === 'string' ? obj['serverBundleUrl'] : undefined,
+        serverIntegrity: typeof obj['serverIntegrity'] === 'string' ? obj['serverIntegrity'] : undefined,
         requires,
     };
 }

package/dist/registry/types.d.ts

@@ -117,6 +117,15 @@ export interface PackageVersion {
      * manifest.
      */
     serverBundleUrl?: string;
+    /**
+     * SRI integrity hash for the server bundle. Same format as `integrity`.
+     * Optional in contract v1 for back-compat with registries that predate
+     * server bundles. Will become required when the formal registry spec
+     * lands (see ADR-015 proposal). When absent, the client skips the SRI
+     * check at download time and logs a warning — the unverified bundle is
+     * still installed.
+     */
+    serverIntegrity?: string;
     /**
      * Other shards that must be installed and active before this package
      * can be loaded. Optional — omit if the package has no dependencies.

package/dist/shards/activate.svelte.js

@@ -17,7 +17,7 @@
  *   stays in `registeredShards` — it's still known, just not running.
  */
 import { shell } from '../shellRuntime.svelte';
-import { registerView, unregisterView } from './registry';
+import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb } from './registry';
 import { createDocumentHandle, getTenantId, getDocumentBackend } from '../documents';
 import { fetchEnvState, putEnvState } from '../env/client';
 import { isAdmin as checkIsAdmin } from '../auth/index';
@@ -75,7 +75,7 @@ export async function activateShard(id) {
         // and is now being required by an app). Idempotent — no error.
         return;
     }
-    const entry = { shard, ctx: undefined, viewIds: new Set(), cleanupFns: [] };
+    const entry = { shard, ctx: undefined, viewIds: new Set(), verbNames: new Set(), cleanupFns: [] };
     // envState holds the reactive env data for this shard.
     // Must be declared with $state at variable declaration time (Svelte 5 rule).
     const envState = $state({
@@ -88,6 +88,11 @@ export async function activateShard(id) {
             registerView(viewId, factory);
             entry.viewIds.add(viewId);
         },
+        registerVerb: (verb) => {
+            const prefixed = id === 'shell' ? verb.name : `${id}:${verb.name}`;
+            fwRegisterVerb(prefixed, Object.assign(Object.assign({}, verb), { name: prefixed }));
+            entry.verbNames.add(prefixed);
+        },
         documents: (options) => {
             const handle = createDocumentHandle(getTenantId(), id, getDocumentBackend(), options);
             entry.cleanupFns.push(() => handle.dispose());
@@ -163,6 +168,8 @@ export function deactivateShard(id) {
     // Flush and dispose document handles before tearing down views.
     for (const fn of entry.cleanupFns)
         void fn();
+    for (const name of entry.verbNames)
+        fwUnregisterVerb(name);
     for (const viewId of entry.viewIds)
         unregisterView(viewId);
     active.delete(id);

package/dist/shards/registry.d.ts

@@ -2,3 +2,8 @@ import type { ViewFactory } from './types';
 export declare function registerView(viewId: string, factory: ViewFactory): void;
 export declare function getView(viewId: string): ViewFactory | undefined;
 export declare function unregisterView(viewId: string): void;
+import type { Verb } from '../verbs/types';
+export declare function registerVerb(name: string, verb: Verb): void;
+export declare function getVerb(name: string): Verb | undefined;
+export declare function unregisterVerb(name: string): void;
+export declare function listVerbs(): Verb[];

package/dist/shards/registry.js

@@ -1,5 +1,5 @@
 /*
- * Contribution registry — phase 4 stub.
+ * Contribution registry — views and verbs.
  *
  * Tracks which ViewFactory answers a given viewId. In this phase the
  * registry is a flat module-level Map with no awareness of shard identity;
@@ -10,8 +10,8 @@
  * The shape of this registry is deliberately narrow so later phases can
  * expand it without breaking callers:
  *   - Resolution by viewId is the only query slots need.
- *   - Commands, toolbar items, menus, hotkeys get their own sibling maps
- *     (one per contribution kind) when those kinds land.
+ *   - Verbs are the second contribution kind (SH11). Toolbar items, menus,
+ *     hotkeys get their own sibling maps when those kinds land.
  */
 const views = new Map();
 export function registerView(viewId, factory) {
@@ -26,3 +26,19 @@ export function getView(viewId) {
 export function unregisterView(viewId) {
     views.delete(viewId);
 }
+const verbs = new Map();
+export function registerVerb(name, verb) {
+    if (verbs.has(name)) {
+        throw new Error(`Verb "${name}" is already registered`);
+    }
+    verbs.set(name, verb);
+}
+export function getVerb(name) {
+    return verbs.get(name);
+}
+export function unregisterVerb(name) {
+    verbs.delete(name);
+}
+export function listVerbs() {
+    return Array.from(verbs.values()).sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/shards/registry.test.d.ts

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

package/dist/shards/registry.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registerVerb, getVerb, unregisterVerb, listVerbs, } from './registry';
+function makeStubVerb(name) {
+    return { name, summary: `stub ${name}`, run: async () => { } };
+}
+describe('verb registry', () => {
+    const registered = [];
+    beforeEach(() => {
+        for (const name of registered)
+            unregisterVerb(name);
+        registered.length = 0;
+    });
+    function trackVerb(name, verb) {
+        registerVerb(name, verb);
+        registered.push(name);
+    }
+    it('registers and retrieves a verb by name', () => {
+        const verb = makeStubVerb('foo');
+        trackVerb('foo', verb);
+        expect(getVerb('foo')).toBe(verb);
+    });
+    it('returns undefined for unknown verb', () => {
+        expect(getVerb('nope')).toBeUndefined();
+    });
+    it('throws on duplicate verb name', () => {
+        trackVerb('dup', makeStubVerb('dup'));
+        expect(() => trackVerb('dup', makeStubVerb('dup'))).toThrowError('Verb "dup" is already registered');
+    });
+    it('unregisters a verb', () => {
+        trackVerb('gone', makeStubVerb('gone'));
+        unregisterVerb('gone');
+        registered.pop();
+        expect(getVerb('gone')).toBeUndefined();
+    });
+    it('lists verbs sorted by name', () => {
+        trackVerb('zeta', makeStubVerb('zeta'));
+        trackVerb('alpha', makeStubVerb('alpha'));
+        trackVerb('mid', makeStubVerb('mid'));
+        const names = listVerbs().map((v) => v.name);
+        expect(names).toEqual(['alpha', 'mid', 'zeta']);
+    });
+    it('stores prefixed name inside verb object (mirrors activate auto-prefix)', () => {
+        // activate.svelte.ts does: { ...verb, name: prefixed }
+        const original = makeStubVerb('install');
+        const prefixed = Object.assign(Object.assign({}, original), { name: 'registry:install' });
+        trackVerb('registry:install', prefixed);
+        const found = getVerb('registry:install');
+        expect(found === null || found === void 0 ? void 0 : found.name).toBe('registry:install');
+        expect(found === null || found === void 0 ? void 0 : found.summary).toBe('stub install');
+    });
+    it('bulk unregister simulates deactivate cleanup', () => {
+        // activate.svelte.ts tracks verbNames and unregisters on deactivate
+        const names = ['registry:install', 'registry:search', 'registry:info'];
+        for (const name of names)
+            trackVerb(name, makeStubVerb(name));
+        expect(listVerbs()).toHaveLength(3);
+        for (const name of names)
+            unregisterVerb(name);
+        registered.length = 0; // already cleaned
+        expect(listVerbs()).toHaveLength(0);
+    });
+});

package/dist/shards/types.d.ts

@@ -2,6 +2,7 @@ import type { StateZones } from '../state/zones.svelte';
 import type { ZoneSchema, ZoneManager } from '../state/types';
 import type { DocumentHandle, DocumentHandleOptions } from '../documents/types';
 import type { EnvState } from '../env/types';
+import type { Verb } from '../verbs/types';
 /**
  * The object returned by `ViewFactory.mount`. The framework calls
  * `unmount()` when the slot goes away, and `onResize(w, h)` whenever the
@@ -77,16 +78,18 @@ export interface ViewDeclaration {
     icon?: string;
 }
 /**
- * Static description of a shard. Declared once and read by the framework
- * before `activate` runs, so the shell can enumerate a shard's capabilities
- * without executing any shard code.
+ * Static description of a shard as observed by the framework and consumers
+ * at runtime. `version` is always present here: for externally installed
+ * packages it is stamped by the installer from the registry entry, for
+ * in-tree shards it is set from `VERSION` (the auto-generated constant
+ * derived from `sh3-core`'s own `package.json`). See ADR-013.
  */
 export interface ShardManifest {
     /** Unique shard identifier. Used as the state namespace and view id prefix. */
     id: string;
     /** Human-readable display name. */
     label: string;
-    /** Semver version string for the shard package. */
+    /** Semver version string. Always present at load time — see `SourceShardManifest` for what authors write. */
     version: string;
     /**
      * Static list of the view ids this shard provides. Every id listed here
@@ -111,6 +114,17 @@ export interface ShardManifest {
      */
     permissions?: string[];
 }
+/**
+ * Source-declared shape of a shard manifest — what external package authors
+ * write in their own code. `version` is omitted because it would duplicate
+ * `package.json.version`; the framework injects it at load time. See ADR-013.
+ *
+ * Authors who want a source file type can use `SourceShard` (which carries
+ * `manifest: SourceShardManifest`). In-tree shards that import `VERSION`
+ * from `sh3-core`'s auto-generated `version.ts` can keep using the full
+ * `Shard` / `ShardManifest` types directly.
+ */
+export type SourceShardManifest = Omit<ShardManifest, 'version'>;
 /**
  * Handed to `shard.activate`. The shard uses it to declare state and
  * register contributions. `state` is pre-bound to the shard's id so the
@@ -135,6 +149,14 @@ export interface ShardContext {
      * @param factory - The adapter that mounts the view into a container element.
      */
     registerView(viewId: string, factory: ViewFactory): void;
+    /**
+     * Register a verb that users can invoke from the shell terminal.
+     * The verb name is auto-prefixed with `shardId:` for non-shell shards.
+     * Automatically unregistered when the shard deactivates.
+     *
+     * @param verb - The verb definition (name, summary, run function).
+     */
+    registerVerb(verb: Verb): void;
     /** Obtain a file-oriented document handle scoped to this shard. */
     documents(options: DocumentHandleOptions): DocumentHandle;
     /**
@@ -205,3 +227,13 @@ export interface Shard {
      */
     resume?(ctx: ShardContext): void | Promise<void>;
 }
+/**
+ * Source-level shape of a shard as written by external package authors.
+ * Carries a `SourceShardManifest` (no `version` field). The framework
+ * injects `version` from the registry entry's `PackageVersion.version`
+ * at install time, after which the object is observed as a full `Shard`.
+ * See ADR-013.
+ */
+export interface SourceShard extends Omit<Shard, 'manifest'> {
+    manifest: SourceShardManifest;
+}

package/dist/shell-shard/Terminal.svelte

@@ -5,7 +5,6 @@
   import InputLine from './InputLine.svelte';
   import { SessionClient } from './session-client.svelte';
   import { VerbRegistry, type ShellApi } from './registry';
-  import { registerV1Verbs } from './verbs';
   import type { ServerMessage } from './protocol';
 
   interface Props {
@@ -18,13 +17,13 @@
   // wsUrl is a prop read at construction only. untrack prevents Svelte 5's
   // "referenced outside a closure" warning; the URL never changes at runtime.
   const session = untrack(() => new SessionClient(wsUrl));
-  const registry = new VerbRegistry();
-  registerV1Verbs(registry);
+  const resolver = new VerbRegistry();
 
   let locked = $state(false);
 
   async function dispatch(line: string): Promise<void> {
-    const resolution = registry.resolve(line);
+    session.history.push(line);
+    const resolution = resolver.resolve(line);
     if (resolution.kind === 'local') {
       // Log locally-dispatched verbs for shared history
       session.send({ t: 'history-log', line });
@@ -71,14 +70,20 @@
         scrollback.push({ kind: 'text', stream: 'stderr', chunks: [e.data], ts: e.ts });
         break;
       case 'exit':
-        scrollback.push({
-          kind: 'status',
-          text: e.signal
-            ? `shell: process exited (${e.signal})`
-            : `shell: process exited (${e.code ?? 0})`,
-          level: e.code === 0 || e.code === null ? 'info' : 'error',
-          ts: e.ts,
-        });
+        // Match real-shell UX: stay silent on clean exit. Only surface
+        // a status line on non-zero exit codes or signal-terminated
+        // processes (SIGINT, spawn errors, etc.). `code === null` with
+        // no signal happens on clean close too — treat as success.
+        if (e.signal || (e.code !== null && e.code !== 0)) {
+          scrollback.push({
+            kind: 'status',
+            text: e.signal
+              ? `shell: process exited (${e.signal})`
+              : `shell: process exited (${e.code})`,
+            level: 'error',
+            ts: e.ts,
+          });
+        }
         locked = false;
         break;
       case 'status':

package/dist/shell-shard/manifest.js

@@ -1,7 +1,8 @@
+import { VERSION } from '../version';
 export const manifest = {
     id: 'shell',
     label: 'Shell',
-    version: '0.1.0',
+    version: VERSION,
     views: [{ id: 'shell:terminal', label: 'Shell' }],
     // serverBundle intentionally omitted — this shard is a framework built-in
     // and is statically mounted at sh3-server boot. The existing contract in

package/dist/shell-shard/registry.d.ts

@@ -1,68 +1,6 @@
-import type { Scrollback } from './scrollback.svelte';
-import type { SessionClient } from './session-client.svelte';
-export interface ShellApi {
-    listApps(): Array<{
-        id: string;
-        label: string;
-    }>;
-    getActiveApp(): {
-        id: string;
-        label: string;
-    } | null;
-    launchApp(id: string): void;
-    listShards(): Array<{
-        id: string;
-        label: string;
-        version: string;
-    }>;
-    listViewsInCurrentLayout(): Array<{
-        slotId: string;
-        viewId: string;
-        label: string;
-    }>;
-    openViewInCurrentLayout(viewId: string): {
-        ok: boolean;
-        error?: string;
-    };
-    closeSlot(slotId: string): {
-        ok: boolean;
-        error?: string;
-    };
-    listZones(shardId?: string): Array<{
-        shardId: string;
-        zones: string[];
-    }>;
-    readZone(shardId: string, zoneName: string): unknown;
-    whoAmI(): {
-        userId: string;
-        admin: boolean;
-    };
-}
-export interface VerbContext {
-    shell: ShellApi;
-    scrollback: Scrollback;
-    session: SessionClient;
-    cwd: string;
-    /** Invoke another registered verb programmatically (used by rich-entry clicks). */
-    dispatch(line: string): Promise<void>;
-}
-export interface Verb {
-    name: string;
-    summary: string;
-    run(ctx: VerbContext, args: string[]): Promise<void>;
-}
-export type Resolution = {
-    kind: 'local';
-    verb: Verb;
-    args: string[];
-    line: string;
-} | {
-    kind: 'forward';
-    line: string;
-};
+import type { Verb, VerbContext, Resolution, ShellApi } from '../verbs/types';
+export type { Verb, VerbContext, Resolution, ShellApi };
 export declare class VerbRegistry {
-    private readonly verbs;
-    register(verb: Verb): void;
     list(): Verb[];
     get(name: string): Verb | undefined;
     resolve(line: string): Resolution;

package/dist/shell-shard/registry.js

@@ -1,26 +1,18 @@
 /*
- * Verb registry for shell-shard.
+ * Verb resolution for shell-shard.
  *
- * v1 is internal to shell-shard (not a contribution kind). Holds a map of
- * verb name → Verb definition. Resolution:
- *   1. If first token matches a registered verb → { kind: 'local', verb, args }
- *   2. If first token is '$' → { kind: 'forward', line: rest } (escape hatch)
- *   3. Otherwise → { kind: 'forward', line } (unknown, ship to server)
- *
- * Future: other shards register verbs via a new contribution kind.
+ * The VerbRegistry class owns resolution logic (escape hatch, token
+ * lookup, forward-to-server). Verb storage is the framework's job —
+ * see shards/registry.ts. This class reads from the framework map
+ * via getVerb() and listVerbs().
  */
+import { getVerb, listVerbs } from '../shards/registry';
 export class VerbRegistry {
-    constructor() {
-        this.verbs = new Map();
-    }
-    register(verb) {
-        this.verbs.set(verb.name, verb);
-    }
     list() {
-        return Array.from(this.verbs.values()).sort((a, b) => a.name.localeCompare(b.name));
+        return listVerbs();
     }
     get(name) {
-        return this.verbs.get(name);
+        return getVerb(name);
     }
     resolve(line) {
         const trimmed = line.trim();
@@ -37,7 +29,7 @@ export class VerbRegistry {
         const space = trimmed.indexOf(' ');
         const head = space === -1 ? trimmed : trimmed.slice(0, space);
         const rest = space === -1 ? '' : trimmed.slice(space + 1);
-        const verb = this.verbs.get(head);
+        const verb = getVerb(head);
         if (!verb)
             return { kind: 'forward', line };
         // Simple space-split for args — verbs can re-tokenize if they need quoting

package/dist/shell-shard/shellShard.svelte.js

@@ -15,6 +15,7 @@
 import { mount, unmount } from 'svelte';
 import { manifest } from './manifest';
 import Terminal from './Terminal.svelte';
+import { registerV1Verbs } from './verbs';
 import { listRegisteredApps, getActiveApp } from '../apps/registry.svelte';
 import { launchApp } from '../apps/lifecycle';
 import { registeredShards } from '../shards/activate.svelte';
@@ -62,7 +63,7 @@ function makeShellApi(_ctx) {
         listViewsInCurrentLayout() {
             try {
                 const { root } = inspectActiveLayout();
-                return collectTabEntries(root).map((t) => {
+                return collectTabEntries(root.docked).map((t) => {
                     var _a;
                     return ({
                         slotId: t.slotId,
@@ -114,6 +115,7 @@ export const shellShard = {
             // Non-admin: don't expose the view. Nothing to register.
             return;
         }
+        registerV1Verbs(ctx);
         const shell = makeShellApi(ctx);
         const factory = {
             mount(container, _context) {
@@ -128,6 +130,7 @@ export const shellShard = {
                     unmount() {
                         unmount(instance);
                     },
+                    closable: true,
                 };
             },
         };

package/dist/shell-shard/verbs/apps.d.ts

@@ -1,3 +1,3 @@
-import type { Verb } from '../registry';
+import type { Verb } from '../../verbs/types';
 export declare const appsVerb: Verb;
 export declare const appVerb: Verb;

package/dist/shell-shard/verbs/clear.d.ts

@@ -1,2 +1,2 @@
-import type { Verb } from '../registry';
+import type { Verb } from '../../verbs/types';
 export declare const clearVerb: Verb;

package/dist/shell-shard/verbs/help.d.ts

@@ -1,2 +1,2 @@
-import type { Verb, VerbRegistry } from '../registry';
-export declare function makeHelpVerb(registry: VerbRegistry): Verb;
+import type { Verb } from '../../verbs/types';
+export declare function makeHelpVerb(): Verb;

package/dist/shell-shard/verbs/help.js

@@ -1,10 +1,11 @@
+import { listVerbs } from '../../shards/registry';
 import HelpTable from '../rich/HelpTable.svelte';
-export function makeHelpVerb(registry) {
+export function makeHelpVerb() {
     return {
         name: 'help',
         summary: 'List verbs or show detail for one.',
         async run(ctx) {
-            const rows = registry.list().map((v) => ({ name: v.name, summary: v.summary }));
+            const rows = listVerbs().map((v) => ({ name: v.name, summary: v.summary }));
             ctx.scrollback.push({
                 kind: 'rich',
                 component: HelpTable,

package/dist/shell-shard/verbs/history.d.ts

@@ -1,2 +1,2 @@
-import type { Verb } from '../registry';
+import type { Verb } from '../../verbs/types';
 export declare const historyVerb: Verb;

package/dist/shell-shard/verbs/index.d.ts

@@ -1,2 +1,2 @@
-import type { VerbRegistry } from '../registry';
-export declare function registerV1Verbs(registry: VerbRegistry): void;
+import type { ShardContext } from '../../shards/types';
+export declare function registerV1Verbs(ctx: ShardContext): void;

package/dist/shell-shard/verbs/index.js

@@ -1,6 +1,6 @@
 /*
- * Bundle of v1 verbs for shell-shard. Call registerV1Verbs(registry) once
- * at activate time to populate the registry.
+ * Bundle of v1 verbs for shell-shard. Call registerV1Verbs(ctx) once
+ * during shell-shard activate() to populate the framework verb registry.
  */
 import { makeHelpVerb } from './help';
 import { clearVerb } from './clear';
@@ -10,20 +10,20 @@ import { shardsVerb } from './shards';
 import { viewsVerb, openVerb, closeVerb } from './views';
 import { zonesVerb, zoneVerb } from './zones';
 import { pwdVerb, cdVerb, envVerb, whoamiVerb } from './session';
-export function registerV1Verbs(registry) {
-    registry.register(makeHelpVerb(registry));
-    registry.register(clearVerb);
-    registry.register(historyVerb);
-    registry.register(appsVerb);
-    registry.register(appVerb);
-    registry.register(shardsVerb);
-    registry.register(viewsVerb);
-    registry.register(openVerb);
-    registry.register(closeVerb);
-    registry.register(zonesVerb);
-    registry.register(zoneVerb);
-    registry.register(pwdVerb);
-    registry.register(cdVerb);
-    registry.register(envVerb);
-    registry.register(whoamiVerb);
+export function registerV1Verbs(ctx) {
+    ctx.registerVerb(makeHelpVerb());
+    ctx.registerVerb(clearVerb);
+    ctx.registerVerb(historyVerb);
+    ctx.registerVerb(appsVerb);
+    ctx.registerVerb(appVerb);
+    ctx.registerVerb(shardsVerb);
+    ctx.registerVerb(viewsVerb);
+    ctx.registerVerb(openVerb);
+    ctx.registerVerb(closeVerb);
+    ctx.registerVerb(zonesVerb);
+    ctx.registerVerb(zoneVerb);
+    ctx.registerVerb(pwdVerb);
+    ctx.registerVerb(cdVerb);
+    ctx.registerVerb(envVerb);
+    ctx.registerVerb(whoamiVerb);
 }

package/dist/shell-shard/verbs/session.d.ts

@@ -1,4 +1,4 @@
-import type { Verb } from '../registry';
+import type { Verb } from '../../verbs/types';
 export declare const pwdVerb: Verb;
 export declare const cdVerb: Verb;
 export declare const envVerb: Verb;

package/dist/shell-shard/verbs/shards.d.ts

@@ -1,2 +1,2 @@
-import type { Verb } from '../registry';
+import type { Verb } from '../../verbs/types';
 export declare const shardsVerb: Verb;

package/dist/shell-shard/verbs/views.d.ts

@@ -1,4 +1,4 @@
-import type { Verb } from '../registry';
+import type { Verb } from '../../verbs/types';
 export declare const viewsVerb: Verb;
 export declare const openVerb: Verb;
 export declare const closeVerb: Verb;

package/dist/shell-shard/verbs/zones.d.ts

@@ -1,3 +1,3 @@
-import type { Verb } from '../registry';
+import type { Verb } from '../../verbs/types';
 export declare const zonesVerb: Verb;
 export declare const zoneVerb: Verb;

package/dist/shellRuntime.svelte.d.ts

@@ -3,6 +3,8 @@ import type { ZoneSchema } from './state/types';
 import { type ModalManager } from './overlays/modal';
 import { type PopupManager } from './overlays/popup';
 import { type ToastManager } from './overlays/toast';
+import { type FloatManager } from './overlays/float';
+import { type PresetManager } from './overlays/presets';
 /**
  * The process-wide shell singleton exposed to shards and the shell's own
  * internal code. Provides state zone creation and overlay managers.
@@ -22,6 +24,10 @@ export interface Shell {
     popup: PopupManager;
     /** Auto-dismissing notification toasts. */
     toast: ToastManager;
+    /** Detached floating panels on overlay layer 1. See overlays/float.ts. */
+    float: FloatManager;
+    /** Named layout presets per app. See overlays/presets.ts. */
+    presets: PresetManager;
 }
 /** 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

@@ -18,10 +18,14 @@ import { createStateZones } from './state/zones.svelte';
 import { modalManager } from './overlays/modal';
 import { popupManager } from './overlays/popup';
 import { toastManager } from './overlays/toast';
+import { floatManager } from './overlays/float';
+import { presetManager } from './overlays/presets';
 /** The process-wide shell instance. Framework-internal code uses this directly; shards receive a scoped view via `ShardContext`. */
 export const shell = {
     state: createStateZones,
     modal: modalManager,
     popup: popupManager,
     toast: toastManager,
+    float: floatManager,
+    presets: presetManager,
 };