@astrale-os/shell 0.1.1 → 0.2.0

package/dist/shell/build.js

@@ -0,0 +1,58 @@
+import { createOsNamespaces } from '../application/namespaces';
+/** Assemble the Shell object shared by both modes from their wired parts. */
+export function buildShellFacade(deps) {
+    let disposed = false;
+    // The OS namespaces are lazy over the kernel proxy: constructing them touches
+    // no kernel, so the sandboxed shell's "init() first" guard fires only when a
+    // namespace method actually dispatches.
+    let os = null;
+    const osNamespaces = () => (os ??= createOsNamespaces(deps.kernel));
+    const shell = {
+        get parent() {
+            return deps.parent;
+        },
+        children: deps.childrenChannel,
+        kernel: deps.kernel,
+        windows: deps.windows,
+        get targetNodeId() {
+            return deps.targetNodeId?.();
+        },
+        get user() {
+            return osNamespaces().user;
+        },
+        get spaces() {
+            return osNamespaces().spaces;
+        },
+        get apps() {
+            return osNamespaces().apps;
+        },
+        use(middleware) {
+            deps.pipeline.use(middleware);
+            return shell;
+        },
+        onMessage(handler) {
+            return deps.observer.subscribe(handler);
+        },
+        onIntent(name, handler) {
+            return deps.onIntent(name, handler);
+        },
+        mount(params) {
+            return deps.getMountController().mount(params);
+        },
+        close(windowId, opts) {
+            return deps.getMountController().close(windowId, opts);
+        },
+        async init() {
+            if (deps.init)
+                await deps.init();
+            return shell;
+        },
+        async dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            await deps.onDispose();
+        },
+    };
+    return shell;
+}

package/dist/shell/config.d.ts

@@ -0,0 +1,29 @@
+import type { FunctionSchema } from '@astrale-os/kernel-client';
+import type { ShellAdapter } from '../window/embed/adapter';
+export type StandaloneConfig = {
+    readonly mode: 'standalone';
+    readonly kernelUrl: string;
+    readonly credential?: string;
+    readonly getCredential?: () => string;
+    readonly mintIdentity?: string;
+    readonly schema?: FunctionSchema[];
+    readonly adapter?: ShellAdapter;
+    readonly windowId?: string;
+    /**
+     * Optional wire-layer `fetch` shim for the kernel transport. A cookie-fronted
+     * SPA passes a wrapper adding `credentials:'include'` + refresh-on-401 and an
+     * empty `credential`, so a router unseals the cookie into a Bearer (the SPA
+     * holds no token). Omit it (the default) for token-based callers — including
+     * every sandboxed child view, which authenticates with a delegation token.
+     */
+    readonly fetch?: typeof fetch;
+};
+export type SandboxedConfig = {
+    readonly mode: 'sandboxed';
+    readonly schema?: FunctionSchema[];
+    readonly parentWindow?: WindowProxy;
+    readonly initTimeoutMs?: number;
+    readonly adapter?: ShellAdapter;
+};
+export type ShellConfig = StandaloneConfig | SandboxedConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/shell/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/shell/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE3D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,MAAM,CAAA;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,CAAA;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAA;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,CAAA;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAA;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAA"}

package/dist/shell/create.d.ts

@@ -0,0 +1,4 @@
+import type { ShellConfig } from './config';
+import type { Shell } from './shell';
+export declare function createShell(config: ShellConfig): Shell;
+//# sourceMappingURL=create.d.ts.map

package/dist/shell/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/shell/create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAKpC,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,CAEtD"}

package/dist/shell/create.js

@@ -0,0 +1,5 @@
+import { createSandboxedShell } from './sandboxed/sandboxed';
+import { createStandaloneShell } from './standalone';
+export function createShell(config) {
+    return config.mode === 'standalone' ? createStandaloneShell(config) : createSandboxedShell(config);
+}

package/dist/{application/windowing/child-init.d.ts → shell/sandboxed/boot.d.ts}

@@ -1,8 +1,8 @@
 import type { FunctionSchema } from '@astrale-os/kernel-client';
-import type { DelegationToken } from '../../domain/identity/delegation';
-import type { MessageObserver } from '../channels/observer';
-import type { ParentChannelController } from '../channels/parent-channel';
-import { type DelegationKernelFacadeController } from '../kernel-facade';
+import type { MessageObserver } from '../../channel/observer';
+import type { ParentChannelController } from '../../channel/parent';
+import type { DelegationToken } from '../../kernel/delegation/token';
+import { type DelegationKernelFacadeController } from '../../kernel/delegated';
 export type ChildInitParams = {
     readonly parent: WindowProxy;
     readonly timeoutMs?: number;
@@ -20,4 +20,4 @@ export type ChildInitResult = {
 };
 /** Child-side init: post INIT_REQUEST, receive MessagePort + ctrl:handshake, ack. */
 export declare function performChildInit(params: ChildInitParams): Promise<ChildInitResult>;
-//# sourceMappingURL=child-init.d.ts.map
+//# sourceMappingURL=boot.d.ts.map

package/dist/shell/sandboxed/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../../../src/shell/sandboxed/boot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAKpE,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,wBAAwB,CAAA;AAI/B,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,uBAAuB,CAAA;IAC9E,QAAQ,CAAC,MAAM,EAAE,gCAAgC,CAAA;IACjD,QAAQ,CAAC,YAAY,EAAE,eAAe,CAAA;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAC/B,CAAA;AAID,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAmGlF"}

package/dist/{application/windowing/child-init.js → shell/sandboxed/boot.js}

@@ -1,8 +1,8 @@
-import { createKernelClientAdapter } from '../../adapters/kernel-client.adapter';
-import { createMessagePortTransport } from '../../adapters/message-port.transport';
-import { createParentChannel } from '../channels/parent-channel';
-import { createDelegationKernelFacade, } from '../kernel-facade';
-import { INIT_REQUEST_TYPE, isInitResponse } from './protocol';
+import { createMessagePortTransport } from '../../channel/message-port';
+import { createParentChannel } from '../../channel/parent';
+import { createDelegationKernelFacade, } from '../../kernel/delegated';
+import { createKernelClientAdapter } from '../../kernel/session';
+import { INIT_REQUEST_TYPE, isInitResponse } from '../../message/init';
 const DEFAULT_TIMEOUT = 5_000;
 /** Child-side init: post INIT_REQUEST, receive MessagePort + ctrl:handshake, ack. */
 export function performChildInit(params) {
@@ -44,7 +44,6 @@ export function performChildInit(params) {
                     url: data.kernelUrl,
                     schema: params.schema,
                     getCredential: () => currentToken.credential,
-                    mintIdentity: data.mintIdentity,
                 });
                 const kernel = createDelegationKernelFacade({
                     adapter,

package/dist/shell/sandboxed/guarded.d.ts

@@ -0,0 +1,13 @@
+import type { ParentChannel, ParentChannelController } from '../../channel/parent';
+import type { KernelClient } from '../../kernel/client';
+/** Throw the canonical "call init() first" error while `get()` has no state yet. */
+export declare function requireInit<T>(get: () => T | null): T;
+/**
+ * Forward the whole unified kernel surface (graph sugar + `.call/.stream/…` +
+ * the shell extras) to the post-init facade lazily, so the "init() first"
+ * guard applies uniformly to every member without re-declaring each one.
+ */
+export declare function guardedKernel(require: () => KernelClient): KernelClient;
+/** Same guard for the parent channel — throws on use until `init()` resolves. */
+export declare function guardedParent(require: () => ParentChannelController): ParentChannel;
+//# sourceMappingURL=guarded.d.ts.map

package/dist/shell/sandboxed/guarded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guarded.d.ts","sourceRoot":"","sources":["../../../src/shell/sandboxed/guarded.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,oFAAoF;AACpF,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,GAAG,CAAC,CAIrD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,YAAY,GAAG,YAAY,CAQvE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,uBAAuB,GAAG,aAAa,CAKnF"}

package/dist/shell/sandboxed/guarded.js

@@ -0,0 +1,28 @@
+/** Throw the canonical "call init() first" error while `get()` has no state yet. */
+export function requireInit(get) {
+    const state = get();
+    if (!state)
+        throw new Error('Sandboxed shell not initialized — call shell.init() first');
+    return state;
+}
+/**
+ * Forward the whole unified kernel surface (graph sugar + `.call/.stream/…` +
+ * the shell extras) to the post-init facade lazily, so the "init() first"
+ * guard applies uniformly to every member without re-declaring each one.
+ */
+export function guardedKernel(require) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            const kernel = require();
+            const value = kernel[prop];
+            return typeof value === 'function' ? value.bind(kernel) : value;
+        },
+    });
+}
+/** Same guard for the parent channel — throws on use until `init()` resolves. */
+export function guardedParent(require) {
+    return {
+        send: (message) => require().send(message),
+        on: (type, handler) => require().on(type, handler),
+    };
+}

package/dist/shell/sandboxed/pending.d.ts

@@ -0,0 +1,14 @@
+import type { IntentRouterController, LocalIntentHandler } from '../../intent/router';
+import type { IntentRegistry } from '../../message/intent';
+/**
+ * Buffer intent subscriptions made before `init()` resolves — the router is
+ * only built once the handshake completes, but consumers want to call
+ * `onIntent` at construction time.
+ */
+export interface PendingIntentSubs {
+    add<K extends keyof IntentRegistry>(name: K, handler: LocalIntentHandler<K>): () => void;
+    /** Register the buffered subscriptions on the real router, then drain. */
+    replay(router: IntentRouterController): void;
+}
+export declare function createPendingIntentSubs(): PendingIntentSubs;
+//# sourceMappingURL=pending.d.ts.map

package/dist/shell/sandboxed/pending.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending.d.ts","sourceRoot":"","sources":["../../../src/shell/sandboxed/pending.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACrF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,CAAC,SAAS,MAAM,cAAc,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAA;IACxF,0EAA0E;IAC1E,MAAM,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAA;CAC7C;AASD,wBAAgB,uBAAuB,IAAI,iBAAiB,CA8B3D"}

package/dist/shell/sandboxed/pending.js

@@ -0,0 +1,30 @@
+export function createPendingIntentSubs() {
+    const entries = [];
+    return {
+        add(name, handler) {
+            const entry = {
+                name: name,
+                handler: handler,
+                unsubscribed: false,
+            };
+            entries.push(entry);
+            return () => {
+                entry.unsubscribed = true;
+                // After init, `off` is the router's real disposer (set during replay);
+                // before init, flipping `unsubscribed` is enough (replay skips it).
+                entry.off?.();
+            };
+        },
+        replay(router) {
+            // Capture each real disposer so a post-init unsubscribe (via the closure
+            // returned at add time) actually removes the handler from the router
+            // instead of no-op'ing.
+            for (const entry of entries) {
+                if (entry.unsubscribed)
+                    continue;
+                entry.off = router.onLocal(entry.name, entry.handler);
+            }
+            entries.length = 0;
+        },
+    };
+}

package/dist/shell/sandboxed/sandboxed.d.ts

@@ -0,0 +1,4 @@
+import type { SandboxedConfig } from '../config';
+import type { Shell } from '../shell';
+export declare function createSandboxedShell(config: SandboxedConfig): Shell;
+//# sourceMappingURL=sandboxed.d.ts.map

package/dist/shell/sandboxed/sandboxed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxed.d.ts","sourceRoot":"","sources":["../../../src/shell/sandboxed/sandboxed.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAyBrC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,KAAK,CAkGnE"}

package/dist/shell/sandboxed/sandboxed.js

@@ -0,0 +1,100 @@
+import { createChildrenChannel } from '../../channel/children';
+import { createMessageObserver } from '../../channel/observer';
+import { createIntentPipeline } from '../../intent/pipeline';
+import { createIntentRouter } from '../../intent/router';
+import { createLifecycleController } from '../../window/lifecycle/states';
+import { createMountController } from '../../window/mount/mount';
+import { buildShellFacade } from '../build';
+import { performChildInit } from './boot';
+import { guardedKernel, guardedParent, requireInit } from './guarded';
+import { createPendingIntentSubs } from './pending';
+/** Trusted sender id stamped on intents arriving from the parent channel. */
+const PARENT_SENDER_ID = '<parent>';
+export function createSandboxedShell(config) {
+    const observer = createMessageObserver();
+    const lifecycle = createLifecycleController();
+    const windows = new Map();
+    const childrenChannel = createChildrenChannel({
+        observer,
+        onDeliveryFailed: (toWindowId) => lifecycle.markCrashed(toWindowId),
+    });
+    const pipeline = createIntentPipeline();
+    let state = null;
+    let router = null;
+    let mountController = null;
+    const pending = createPendingIntentSubs();
+    function subscribeIntent(name, handler) {
+        if (router)
+            return router.onLocal(name, handler);
+        return pending.add(name, handler);
+    }
+    const requireState = () => requireInit(() => state);
+    const kernelProxy = guardedKernel(() => requireState().kernel);
+    const parentProxy = guardedParent(() => requireState().parent);
+    function getMountController() {
+        if (mountController)
+            return mountController;
+        if (!config.adapter) {
+            throw new Error('Shell.mount() requires a ShellAdapter in the config');
+        }
+        const current = requireState();
+        mountController = createMountController({
+            adapter: config.adapter,
+            kernel: kernelProxy,
+            kernelUrl: current.kernelUrl,
+            mintIdentity: current.mintIdentity,
+            childrenChannel,
+            windows,
+            lifecycle,
+        });
+        return mountController;
+    }
+    return buildShellFacade({
+        parent: parentProxy,
+        childrenChannel,
+        kernel: kernelProxy,
+        pipeline,
+        observer,
+        lifecycle,
+        windows,
+        getMountController,
+        targetNodeId: () => state?.targetNodeId,
+        onIntent: subscribeIntent,
+        init: async () => {
+            const result = await performChildInit({
+                parent: config.parentWindow ?? window.parent,
+                timeoutMs: config.initTimeoutMs,
+                schema: config.schema,
+            });
+            state = {
+                windowId: result.windowId,
+                kernelUrl: result.kernelUrl,
+                targetNodeId: result.targetNodeId,
+                mintIdentity: result.mintIdentity,
+                kernel: result.kernel,
+                parent: result.parentChannel(observer),
+            };
+            router = createIntentRouter({
+                selfWindowId: state.windowId,
+                pipeline,
+                parent: state.parent,
+                children: childrenChannel,
+                windows,
+            });
+            childrenChannel.on('intent', (windowId, message) => {
+                void router.handleInbound('child', message, windowId);
+            });
+            state.parent.on('intent', (message) => {
+                void router.handleInbound('parent', message, PARENT_SENDER_ID);
+            });
+            pending.replay(router);
+        },
+        onDispose: async () => {
+            if (mountController)
+                await mountController.dispose();
+            childrenChannel.dispose();
+            state?.parent.dispose();
+            state?.kernel.dispose();
+        },
+    });
+}

package/dist/shell/shell.d.ts

@@ -0,0 +1,36 @@
+import type { AppsNamespace } from '../application/apps';
+import type { SpacesNamespace } from '../application/spaces';
+import type { UserNamespace } from '../application/user';
+import type { ChildrenChannel } from '../channel/children';
+import type { ObserverHandler } from '../channel/observer';
+import type { ParentChannel } from '../channel/parent';
+import type { IntentMiddleware } from '../intent/pipeline';
+import type { LocalIntentHandler } from '../intent/router';
+import type { KernelClient } from '../kernel/client';
+import type { IntentRegistry } from '../message/intent';
+import type { CloseResult, MountedWindow, MountParams } from '../window/mount/params';
+import type { Window } from '../window/window';
+export interface Shell {
+    readonly parent: ParentChannel | null;
+    readonly children: ChildrenChannel;
+    readonly kernel: KernelClient;
+    readonly windows: ReadonlyMap<string, Window>;
+    readonly targetNodeId?: string;
+    /** OS plane: the caller as a shell-domain `User` — self, current space, roles. */
+    readonly user: UserNamespace;
+    /** OS plane: the caller's readable spaces — list, get, create. */
+    readonly spaces: SpacesNamespace;
+    /** OS plane: apps — install, list per space, open (returns an `AppSession`). */
+    readonly apps: AppsNamespace;
+    use(middleware: IntentMiddleware): Shell;
+    onMessage(handler: ObserverHandler): () => void;
+    onIntent<K extends keyof IntentRegistry>(name: K, handler: LocalIntentHandler<K>): () => void;
+    mount(params: MountParams): Promise<MountedWindow>;
+    close(windowId: string, opts?: {
+        force?: boolean;
+        timeoutMs?: number;
+    }): Promise<CloseResult>;
+    init(): Promise<Shell>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=shell.d.ts.map

package/dist/shell/shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../src/shell/shell.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACrF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAE9C,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAAA;IACrC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;IAClC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAE9B,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;IAChC,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAE5B,GAAG,CAAC,UAAU,EAAE,gBAAgB,GAAG,KAAK,CAAA;IACxC,SAAS,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,IAAI,CAAA;IAC/C,QAAQ,CAAC,CAAC,SAAS,MAAM,cAAc,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAA;IAE7F,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IAClD,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAE7F,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,CAAA;IACtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB"}

package/dist/shell/standalone.d.ts

@@ -0,0 +1,4 @@
+import type { StandaloneConfig } from './config';
+import type { Shell } from './shell';
+export declare function createStandaloneShell(config: StandaloneConfig): Shell;
+//# sourceMappingURL=standalone.d.ts.map

package/dist/shell/standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../../src/shell/standalone.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAcpC,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,GAAG,KAAK,CA+ErE"}

package/dist/shell/standalone.js

@@ -0,0 +1,85 @@
+import { createChildrenChannel } from '../channel/children';
+import { createMessageObserver } from '../channel/observer';
+import { createIntentPipeline } from '../intent/pipeline';
+import { createIntentRouter } from '../intent/router';
+import { createKernelFacade } from '../kernel/credential';
+import { createKernelClientAdapter } from '../kernel/session';
+import { createLifecycleController } from '../window/lifecycle/states';
+import { createMountController } from '../window/mount/mount';
+import { buildShellFacade } from './build';
+const DEFAULT_ROOT_WINDOW_ID = 'root';
+export function createStandaloneShell(config) {
+    const windowId = config.windowId ?? DEFAULT_ROOT_WINDOW_ID;
+    const observer = createMessageObserver();
+    const getCredential = config.getCredential ??
+        (() => {
+            if (config.credential === undefined) {
+                throw new Error('Standalone shell requires credential or getCredential');
+            }
+            return config.credential;
+        });
+    const adapter = createKernelClientAdapter({
+        url: config.kernelUrl,
+        schema: config.schema,
+        getCredential,
+        fetch: config.fetch,
+    });
+    const kernel = createKernelFacade({
+        adapter,
+        getCredential,
+        url: config.kernelUrl,
+        mintIdentity: config.mintIdentity,
+    });
+    const lifecycle = createLifecycleController();
+    const windows = new Map();
+    const childrenChannel = createChildrenChannel({
+        observer,
+        onDeliveryFailed: (toWindowId) => lifecycle.markCrashed(toWindowId),
+    });
+    const pipeline = createIntentPipeline();
+    const router = createIntentRouter({
+        selfWindowId: windowId,
+        pipeline,
+        parent: null,
+        children: childrenChannel,
+        windows,
+    });
+    childrenChannel.on('intent', (fromWindowId, message) => {
+        void router.handleInbound('child', message, fromWindowId);
+    });
+    let mountController = null;
+    function getMountController() {
+        if (mountController)
+            return mountController;
+        if (!config.adapter) {
+            throw new Error('Shell.mount() requires a ShellAdapter in the config');
+        }
+        mountController = createMountController({
+            adapter: config.adapter,
+            kernel,
+            kernelUrl: config.kernelUrl,
+            mintIdentity: config.mintIdentity,
+            childrenChannel,
+            windows,
+            lifecycle,
+        });
+        return mountController;
+    }
+    return buildShellFacade({
+        parent: null,
+        childrenChannel,
+        kernel,
+        pipeline,
+        observer,
+        lifecycle,
+        windows,
+        getMountController,
+        onIntent: (name, handler) => router.onLocal(name, handler),
+        onDispose: async () => {
+            if (mountController)
+                await mountController.dispose();
+            childrenChannel.dispose();
+            adapter.disconnect();
+        },
+    });
+}

package/dist/{domain/window/config.d.ts → window/capabilities.d.ts}

@@ -1,4 +1,4 @@
-import type { IntentRegistry } from '../message/registries';
+import type { IntentRegistry } from '../message/intent';
 export interface SandboxProfile {
     readonly allowScripts: boolean;
     readonly allowForms: boolean;
@@ -15,7 +15,7 @@ export interface WindowConfig {
     readonly capabilities: WindowCapabilities;
     /**
      * Sandbox profile for the iframe.
-     * - `undefined` → adapter default (`DEFAULT_SANDBOX` in iframe.shell-adapter).
+     * - `undefined` → adapter default (`DEFAULT_SANDBOX` in embed/iframe).
      * - `SandboxProfile` → explicit flag set, becomes the `sandbox=…` attribute.
      * - `null` → opt out: no `sandbox` attribute on the iframe at all (the
      *   browser's cross-origin policy is the only remaining isolation). Used
@@ -23,4 +23,4 @@ export interface WindowConfig {
      */
     readonly sandbox?: SandboxProfile | null;
 }
-//# sourceMappingURL=config.d.ts.map
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/window/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/window/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,cAAc,CAAC,CAAA;CACtD;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAA;IAC1C,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAA;IACzC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;CACzC"}

package/dist/{ports/shell-adapter.d.ts → window/embed/adapter.d.ts}

@@ -1,13 +1,14 @@
-import type { WindowConfig } from '../domain/window/config';
+import type { WindowConfig } from '../capabilities';
 export interface WindowHandle {
     readonly element: HTMLIFrameElement | HTMLElement;
     readonly port: MessagePort | null;
     readonly origin: string;
 }
+/** How a window's host element gets created — the shell's embedding extension point. */
 export interface ShellAdapter {
     mount(config: WindowConfig): {
         handle: WindowHandle;
         dispose: () => void;
     };
 }
-//# sourceMappingURL=shell-adapter.d.ts.map
+//# sourceMappingURL=adapter.d.ts.map

package/dist/window/embed/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/window/embed/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,CAAA;IACjD,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,MAAM,IAAI,CAAA;KAAE,CAAA;CAC3E"}

package/dist/{adapters/iframe.shell-adapter.d.ts → window/embed/iframe.d.ts}

@@ -1,4 +1,4 @@
-import type { ShellAdapter } from '../ports/shell-adapter';
+import type { ShellAdapter } from './adapter';
 export type IframeShellAdapterConfig = {
     /**
      * Optional class list applied to every iframe created by this adapter.
@@ -7,4 +7,4 @@ export type IframeShellAdapterConfig = {
     readonly className?: string;
 };
 export declare function createIframeShellAdapter(config?: IframeShellAdapterConfig): ShellAdapter;
-//# sourceMappingURL=iframe.shell-adapter.d.ts.map
+//# sourceMappingURL=iframe.d.ts.map

package/dist/window/embed/iframe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframe.d.ts","sourceRoot":"","sources":["../../../src/window/embed/iframe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,WAAW,CAAA;AAE3D,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC5B,CAAA;AAUD,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,wBAA6B,GAAG,YAAY,CAsC5F"}

package/dist/{application/windowing/lifecycle-controller.d.ts → window/lifecycle/states.d.ts}

@@ -1,5 +1,6 @@
-import type { WindowState } from '../../domain/window/window';
-import { type LifecycleEvent } from '../../domain/window/lifecycle';
+import type { WindowState } from '../window';
+import { type LifecycleEvent } from './transition';
+/** Live per-window lifecycle states, advanced only through the transition machine. */
 export interface LifecycleController {
     register(windowId: string, initial?: WindowState): void;
     apply(windowId: string, event: LifecycleEvent): WindowState | null;
@@ -7,4 +8,4 @@ export interface LifecycleController {
     remove(windowId: string): void;
 }
 export declare function createLifecycleController(): LifecycleController;
-//# sourceMappingURL=lifecycle-controller.d.ts.map
+//# sourceMappingURL=states.d.ts.map

package/dist/window/lifecycle/states.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"states.d.ts","sourceRoot":"","sources":["../../../src/window/lifecycle/states.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAE9D,sFAAsF;AACtF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAA;IACvD,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,WAAW,GAAG,IAAI,CAAA;IAClE,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED,wBAAgB,yBAAyB,IAAI,mBAAmB,CA4B/D"}

package/dist/{application/windowing/lifecycle-controller.js → window/lifecycle/states.js}

@@ -1,4 +1,4 @@
-import { transition } from '../../domain/window/lifecycle';
+import { transition } from './transition';
 export function createLifecycleController() {
     const states = new Map();
     return {

package/dist/{domain/window/lifecycle.d.ts → window/lifecycle/transition.d.ts}

@@ -1,4 +1,4 @@
-import type { WindowState } from './window';
+import type { WindowState } from '../window';
 export type LifecycleEvent = {
     kind: 'hide';
 } | {
@@ -20,8 +20,8 @@ export type TransitionResult = {
     reason: string;
 };
 /**
- * Pure state-machine transition. Used by the lifecycle controller —
+ * Pure state-machine transition. Used by the lifecycle state map —
  * no timers, no side effects here.
  */
 export declare function transition(state: WindowState, event: LifecycleEvent): TransitionResult;
-//# sourceMappingURL=lifecycle.d.ts.map
+//# sourceMappingURL=transition.d.ts.map

package/dist/window/lifecycle/transition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transition.d.ts","sourceRoot":"","sources":["../../../src/window/lifecycle/transition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAA;AAE1B,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9F;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,cAAc,GAAG,gBAAgB,CAsBtF"}

package/dist/{domain/window/lifecycle.js → window/lifecycle/transition.js}

@@ -1,5 +1,5 @@
 /**
- * Pure state-machine transition. Used by the lifecycle controller —
+ * Pure state-machine transition. Used by the lifecycle state map —
  * no timers, no side effects here.
  */
 export function transition(state, event) {