sh3-core 0.21.2 → 0.22.0

package/dist/layout/types.test.js

@@ -24,3 +24,31 @@ describe('LAYOUT_SCHEMA_VERSION', () => {
         expect(LAYOUT_SCHEMA_VERSION).toBe(7);
     });
 });
+describe('SlotNode props', () => {
+    it('accepts optional props', () => {
+        var _a;
+        const node = {
+            type: 'slot',
+            slotId: 'slot-1',
+            viewId: 'my:view',
+            props: { filePath: '/foo.guml', count: 3, flag: true, nul: null },
+        };
+        expect((_a = node.props) === null || _a === void 0 ? void 0 : _a.filePath).toBe('/foo.guml');
+    });
+    it('omitting props is valid', () => {
+        const node = { type: 'slot', slotId: 's', viewId: null };
+        expect(node.props).toBeUndefined();
+    });
+});
+describe('TabEntry props', () => {
+    it('accepts optional props', () => {
+        var _a;
+        const entry = {
+            slotId: 'slot-1',
+            viewId: 'my:view',
+            label: 'My View',
+            props: { x: 1 },
+        };
+        expect((_a = entry.props) === null || _a === void 0 ? void 0 : _a.x).toBe(1);
+    });
+});

package/dist/overlays/FloatFrame.svelte

@@ -35,6 +35,7 @@
   import { makeSelectionApi } from '../actions/selection.svelte';
   import { spawnSatellite } from '../sh3Api/window';
   import { walkShardsForContent } from '../satellite/walkShards';
+  import { getActiveScopeId, getPersonalScopeId } from '../documents/config';
   import { logGesture } from '../gestures';
 
   const isTauri =
@@ -256,13 +257,15 @@
   async function onPopOut(e: MouseEvent): Promise<void> {
     e.stopPropagation();
     try {
+      const scopeId = getActiveScopeId();
+      const personalId = getPersonalScopeId();
       await spawnSatellite({
         kind: 'float',
         content: entry.content,
         title: entry.title,
         size: { w: entry.size.w, h: entry.size.h },
         activateShards: walkShardsForContent(entry.content),
-        projectId: sh3.getActiveScope().isProject ? sh3.getActiveScope().id : undefined,
+        projectId: scopeId !== personalId ? scopeId : undefined,
       });
       floatManager.close(entry.id);
     } catch (err) {

package/dist/overlays/float.d.ts

@@ -1,4 +1,4 @@
-import type { LayoutNode, FloatEntry } from '../layout/types';
+import type { LayoutNode, FloatEntry, JsonValue } from '../layout/types';
 import type { Size } from '../layout/floats';
 export interface FloatOptions {
     title?: string;
@@ -9,6 +9,12 @@ export interface FloatOptions {
     size?: Size;
     /** Instance data threaded to the view factory via `MountContext.meta`. */
     meta?: Record<string, unknown>;
+    /**
+     * Serializable view props threaded to the factory via `MountContext.props`
+     * and persisted with the float entry. Survives `popoutView` → `dockFloat`
+     * round-trip. JSON-safe values only.
+     */
+    props?: Record<string, JsonValue>;
     /**
      * When true, the float dismisses on any pointerdown outside its frame,
      * is not dockable, and renders without a header when `title` is unset.

package/dist/overlays/float.js

@@ -150,6 +150,8 @@ function openFloat(viewId, options = {}) {
         };
         if (options.meta)
             slot.meta = options.meta;
+        if (options.props)
+            slot.props = options.props;
         content = slot;
     }
     else {
@@ -157,6 +159,8 @@ function openFloat(viewId, options = {}) {
         const tab = { slotId, viewId, label };
         if (options.meta)
             tab.meta = options.meta;
+        if (options.props)
+            tab.props = options.props;
         content = {
             type: 'tabs',
             tabs: [tab],

package/dist/projects-shard/ProjectsSection.svelte

@@ -90,11 +90,7 @@
     border-color: var(--sh3-accent);
     transform: translateY(-1px);
   }
-  .project-card.active {
-    border-color: var(--sh3-accent);
-    box-shadow: 0 0 0 2px color-mix(in srgb, var(--sh3-accent) 40%, transparent);
-  }
-  .project-name { font-weight: 600; font-size: 13px; }
+.project-name { font-weight: 600; font-size: 13px; }
   .project-meta { font-size: 11px; color: var(--sh3-fg-muted); }
   .leave-project {
     display: flex;

package/dist/shards/activate-runtime.test.js

@@ -297,3 +297,48 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         expect(names.find((n) => n.startsWith('ignored:'))).toBeUndefined();
     });
 });
+// ─── registerContributions ────────────────────────────────────────────────────
+describe('registerContributions hook', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __resetViewRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setActiveScope('tenant-test');
+    });
+    it('is called after activate() with the same ShardContext', async () => {
+        const order = [];
+        let activateCtx = null;
+        let registerCtx = null;
+        registerShard({
+            manifest: { id: 'rc-shard', label: 'RC', version: '0.0.0', views: [] },
+            activate(ctx) {
+                activateCtx = ctx;
+                order.push('activate');
+            },
+            registerContributions(ctx) {
+                registerCtx = ctx;
+                order.push('registerContributions');
+            },
+        });
+        await activateShard('rc-shard');
+        expect(order).toEqual(['activate', 'registerContributions']);
+        expect(registerCtx).toBe(activateCtx);
+    });
+    it('is not called when the hook is absent', async () => {
+        registerShard({
+            manifest: { id: 'no-rc', label: 'NoRC', version: '0.0.0', views: [] },
+            activate() { },
+        });
+        await expect(activateShard('no-rc')).resolves.toBeUndefined();
+    });
+    it('is not called when activate() throws', async () => {
+        const registerContributions = vi.fn();
+        registerShard({
+            manifest: { id: 'fail-rc', label: 'FailRC', version: '0.0.0', views: [] },
+            activate() { throw new Error('boom'); },
+            registerContributions,
+        });
+        await expect(activateShard('fail-rc')).rejects.toThrow('boom');
+        expect(registerContributions).not.toHaveBeenCalled();
+    });
+});

package/dist/shards/activate.svelte.js

@@ -18,6 +18,7 @@
  */
 import { sh3 } from '../sh3Runtime.svelte';
 import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb } from './registry';
+import { getShardBinding } from './app-binding.svelte';
 import { makeSh3Api } from '../sh3Api/headless';
 import { createDocumentHandle, getDocumentBackend, getActiveScopeId } from '../documents';
 import { fetchEnvState, putEnvState } from '../env/client';
@@ -179,7 +180,7 @@ export async function activateShard(id, opts) {
             }
         },
         documents: (options) => {
-            const handle = createDocumentHandle(getActiveScopeId(), id, getDocumentBackend(), options);
+            const handle = createDocumentHandle(getActiveScopeId, () => { var _a; return (_a = getShardBinding(id)) !== null && _a !== void 0 ? _a : id; }, getDocumentBackend(), options);
             entry.cleanupFns.push(() => handle.dispose());
             return handle;
         },
@@ -329,6 +330,9 @@ export async function activateShard(id, opts) {
     }
     // Activation succeeded — clear any prior error record for this shard.
     erroredShards.delete(id);
+    if (shard.registerContributions) {
+        shard.registerContributions(ctx);
+    }
     void ((_l = shard.autostart) === null || _l === void 0 ? void 0 : _l.call(shard, ctx));
 }
 /**

package/dist/shards/app-binding.svelte.d.ts

@@ -0,0 +1,8 @@
+/** Record that `shardId` is currently part of `appId`. Overwrites any prior binding. */
+export declare function bindShardToApp(shardId: string, appId: string): void;
+/** Remove the binding for `shardId`. No-op if not bound. */
+export declare function clearShardBinding(shardId: string): void;
+/** Return the app id this shard is currently bound to, or null. */
+export declare function getShardBinding(shardId: string): string | null;
+/** Test-only reset. */
+export declare function __resetShardBindingsForTest(): void;

package/dist/shards/app-binding.svelte.js

@@ -0,0 +1,30 @@
+/*
+ * Shard ↔ app binding registry.
+ *
+ * Records which app (if any) currently owns each active shard. Read by
+ * `ctx.documents()` so its handle's namespace can resolve to `{appId}` instead
+ * of `{shardId}` when the shard is required by a running app — the framework
+ * default for app-shared document namespaces.
+ *
+ * Set by `launchApp` for non-autostart required shards. Cleared by
+ * `unloadApp` (also for non-autostart required shards; autostart shards
+ * never get a binding in the first place since they serve multiple apps).
+ */
+const bindings = $state(new Map());
+/** Record that `shardId` is currently part of `appId`. Overwrites any prior binding. */
+export function bindShardToApp(shardId, appId) {
+    bindings.set(shardId, appId);
+}
+/** Remove the binding for `shardId`. No-op if not bound. */
+export function clearShardBinding(shardId) {
+    bindings.delete(shardId);
+}
+/** Return the app id this shard is currently bound to, or null. */
+export function getShardBinding(shardId) {
+    var _a;
+    return (_a = bindings.get(shardId)) !== null && _a !== void 0 ? _a : null;
+}
+/** Test-only reset. */
+export function __resetShardBindingsForTest() {
+    bindings.clear();
+}

package/dist/shards/app-binding.test.d.ts

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

package/dist/shards/app-binding.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { bindShardToApp, clearShardBinding, getShardBinding, __resetShardBindingsForTest, } from './app-binding.svelte';
+describe('shardAppBindings', () => {
+    beforeEach(__resetShardBindingsForTest);
+    it('returns null for an unbound shard', () => {
+        expect(getShardBinding('shard-A')).toBeNull();
+    });
+    it('records and reads a binding', () => {
+        bindShardToApp('shard-A', 'app-X');
+        expect(getShardBinding('shard-A')).toBe('app-X');
+    });
+    it('overwrites a prior binding (e.g. shard switching apps)', () => {
+        bindShardToApp('shard-A', 'app-X');
+        bindShardToApp('shard-A', 'app-Y');
+        expect(getShardBinding('shard-A')).toBe('app-Y');
+    });
+    it('clears a binding back to null', () => {
+        bindShardToApp('shard-A', 'app-X');
+        clearShardBinding('shard-A');
+        expect(getShardBinding('shard-A')).toBeNull();
+    });
+    it('clearShardBinding on an unbound shard is a no-op', () => {
+        expect(() => clearShardBinding('shard-A')).not.toThrow();
+    });
+});

package/dist/shards/types.d.ts

@@ -9,7 +9,7 @@ import type { Sh3Api } from '../verbs/types';
 import type { ShardContextKeys } from '../keys/types';
 import type { ContributionsApi } from '../contributions/types';
 import type { ActionsApi } from '../actions/types';
-import type { TreeRootRef, SlotRole } from '../layout/types';
+import type { TreeRootRef, SlotRole, JsonValue, RestoredSlot } from '../layout/types';
 export { PERMISSION_KEYS_MINT, type ShardContextKeys, type ApiKeyPublic, type MintOpts, ScopeEscalationError, ConsentDeniedError } from '../keys/types';
 /**
  * The object returned by `ViewFactory.mount`. The framework calls
@@ -65,6 +65,13 @@ export interface MountContext {
      * Not persisted with the layout — ephemeral per mount.
      */
     meta?: Record<string, unknown>;
+    /**
+     * Persistent view-level parameters passed by the caller when opening
+     * this view. Serialized with the layout tree — present on every mount
+     * including layout restore. Undefined when the slot was opened without
+     * props. Values are JSON-safe (`JsonValue`).
+     */
+    props?: Record<string, JsonValue>;
     /**
      * Push dirty-state to the tab strip. The framework renders a dirty
      * indicator (filled dot) on the tab when true, clears it when false.
@@ -84,6 +91,21 @@ export interface MountContext {
      */
     location(): TreeRootRef | null;
 }
+/**
+ * Passed to `Shard.onAppActivate`. The `documents()` factory remains for
+ * back-compat (it returns a handle scoped to the app namespace, identical
+ * to what `ctx.documents()` now returns by default). Prefer `ctx.documents()`
+ * in new code — the framework auto-scopes the shard's existing handle to
+ * the active app's namespace via `shardAppBindings`.
+ *
+ * @deprecated Use `ctx.documents()` — auto-binds to the active app.
+ */
+export interface AppActivateContext {
+    /** The id of the app that just became active. */
+    readonly appId: string;
+    /** @deprecated Use `ctx.documents()`. */
+    documents(options?: DocumentHandleOptions): DocumentHandle;
+}
 /**
  * The shard-side adapter that knows how to bring a view to life inside a
  * given HTMLElement. The container is owned by the framework (the slot);
@@ -350,15 +372,10 @@ export interface Shard {
      */
     activate(ctx: ShardContext): void | Promise<void>;
     /**
-     * Optional self-starting hook. A shard that defines `autostart` is
-     * eagerly activated by the framework at boot (right after the register
-     * pass finishes) instead of waiting for an app to require it. `activate`
-     * runs first; `autostart` runs immediately after and may take imperative
-     * action — docking its own views into the active layout, opening a
-     * modal, subscribing to framework state, etc. The `__sh3core__` pseudo-
-     * shard uses this with a no-op body so its activation path is uniform
-     * with other self-starting shards. Diagnostic-style shards use it to
-     * do real work.
+     * @deprecated Use `registerContributions(ctx)` for static registrations
+     * and `activate(ctx)` for imperative setup. `autostart` will be removed
+     * in a future ADR — see ADR-026. Existing shards using `autostart` are
+     * not broken; this is a migration signal only.
      */
     autostart?(ctx: ShardContext): void | Promise<void>;
     /** Optional cleanup hook called when the shard is deactivated. Release timers, subscriptions, and external resources here. */
@@ -376,6 +393,56 @@ export interface Shard {
     resume?(ctx: ShardContext): void | Promise<void>;
     /** Fires when a key minted by this shard is revoked from any source. */
     onKeyRevoked?(id: string): void | Promise<void>;
+    /**
+     * Register views, commands, hotkey bindings, verbs, toolbar items, and
+     * menu entries — anything that doesn't depend on session state. Called
+     * once after `activate()`. Separating static registrations from ceremony
+     * allows the framework to re-call this on hot-reload without re-running
+     * the full activation lifecycle. All contributions registered here are
+     * auto-unregistered when the shard deactivates.
+     *
+     * Shards that currently register everything inside `activate()` need not
+     * move — `activate()` still works. Use `registerContributions()` for new
+     * shards or when you want hot-reload-safe contribution registration.
+     */
+    registerContributions?(ctx: ShardContext): void;
+    /**
+     * Called after all required shards have activated and the app's document
+     * namespace binding is established. Use this hook for app-context-aware
+     * setup (e.g. preloading docs, registering app-specific contributions).
+     * The shard's existing `ctx.documents()` handle is already auto-bound to
+     * the app namespace — there is no need to re-mint or swap handles here.
+     *
+     * The `appCtx.documents()` factory is retained for back-compat but is
+     * deprecated; new code should use `ctx.documents()`.
+     */
+    onAppActivate?(appId: string, appCtx: AppActivateContext): void | Promise<void>;
+    /**
+     * Called when the app this shard was part of is unloaded — a different app
+     * is launched (the current one is force-unloaded), or `unregisterApp` is
+     * called. NOT fired by `returnToHome` — that path keeps the app alive and
+     * uses the `suspend`/`resume` hooks instead. The shard remains active; its
+     * background services and standalone document handles are still valid.
+     * Use this to release app-scoped document handles and revert to standalone
+     * state.
+     */
+    onAppDeactivate?(appId: string): void | Promise<void>;
+    /**
+     * Called BEFORE layout slots begin mounting, after all required shards have
+     * activated. `slots` contains every slot in the restored layout tree that
+     * has a non-null viewId, including their persisted `props`. Register any
+     * slot-specific contributions here (e.g. `EDITOR_DOCUMENT_POINT` keyed by
+     * `slotId`) so they are in place when the view factory's `mount()` is called.
+     */
+    onLayoutWillRestore?(slots: RestoredSlot[]): void | Promise<void>;
+    /**
+     * Called AFTER the layout has been switched to the app's tree and slots
+     * have begun mounting. Use for post-mount wiring and reconciliation.
+     * Note: view factories may still be mounting asynchronously (microtask);
+     * this hook fires after the layout render, not after all `mount()` calls
+     * have returned.
+     */
+    onLayoutRestored?(slots: RestoredSlot[]): void;
 }
 /**
  * Source-level shape of a shard as written by external package authors.

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

@@ -25,6 +25,7 @@ import { focusView } from '../layout/inspection';
 import { floatManager } from '../overlays/float';
 import { getUser, isAdmin } from '../auth/index';
 import { __bindZone, __unbindZone } from './buffer-zone-state.svelte';
+import { getAuthToken } from '../transport/authToken';
 export { makeSh3ApiHeadless, makeSh3ApiForTest } from '../sh3Api/headless';
 export const shellShard = {
     manifest,
@@ -58,7 +59,15 @@ export const shellShard = {
                 var _a;
                 const proto = typeof location !== 'undefined' && location.protocol === 'https:' ? 'wss' : 'ws';
                 const host = typeof location !== 'undefined' ? location.host : 'localhost';
-                const wsUrl = `${proto}://${host}/api/shell/session`;
+                let wsUrl = `${proto}://${host}/api/shell/session`;
+                // Tauri WebSocket can't set Authorization headers; use the query-param
+                // token fallback already supported by extractSessionToken() in auth.ts.
+                const isTauri = typeof window !== 'undefined' && ('__TAURI_INTERNALS__' in window || '__TAURI__' in window);
+                if (isTauri) {
+                    const tok = getAuthToken();
+                    if (tok)
+                        wsUrl += `?token=${encodeURIComponent(tok)}`;
+                }
                 const user = getUser();
                 const userId = (_a = user === null || user === void 0 ? void 0 : user.id) !== null && _a !== void 0 ? _a : 'guest';
                 const role = isAdmin() ? 'admin' : 'user';

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.21.2";
+export declare const VERSION = "0.22.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.21.2';
+export const VERSION = '0.22.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.21.2",
+  "version": "0.22.0",
   "type": "module",
   "files": [
     "dist"