@astrale-os/shell 0.1.0 → 0.2.0

package/dist/application/shell.js

@@ -1,256 +0,0 @@
-import { createKernelClientAdapter } from '../adapters/kernel-client.adapter';
-import { createChildrenChannel } from './channels/children-channel';
-import { createMessageObserver } from './channels/observer';
-import { createIntentPipeline } from './intent/pipeline-runner';
-import { createIntentRouter } from './intent/router';
-import { createKernelFacade } from './kernel-facade';
-import { performChildInit } from './windowing/child-init';
-import { createLifecycleController } from './windowing/lifecycle-controller';
-import { createMountController } from './windowing/mount-controller';
-const DEFAULT_ROOT_WINDOW_ID = 'root';
-/** Trusted sender id stamped on intents arriving from the parent channel. */
-const PARENT_SENDER_ID = '<parent>';
-// ─── Factory ────────────────────────────────────────────────────────────────
-export function createShell(config) {
-    return config.mode === 'standalone' ? createStandaloneShell(config) : createSandboxedShell(config);
-}
-// ─── Standalone ─────────────────────────────────────────────────────────────
-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,
-        mintIdentity: config.mintIdentity,
-        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', (windowId, message) => {
-        void router.handleInbound('child', message, windowId);
-    });
-    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();
-        },
-    });
-}
-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 pendingIntentSubs = [];
-    function subscribeIntent(name, handler) {
-        if (router)
-            return router.onLocal(name, handler);
-        const entry = {
-            name: name,
-            handler: handler,
-            unsubscribed: false,
-        };
-        pendingIntentSubs.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?.();
-        };
-    }
-    const requireState = () => {
-        if (!state)
-            throw new Error('Sandboxed shell not initialized — call shell.init() first');
-        return state;
-    };
-    const kernelProxy = {
-        call: (path, params) => requireState().kernel.call(path, params),
-        mintDelegation: () => requireState().kernel.mintDelegation(),
-        authToken: () => requireState().kernel.authToken(),
-        get url() {
-            return requireState().kernel.url;
-        },
-    };
-    const parentProxy = {
-        send: (message) => requireState().parent.send(message),
-        on: (type, handler) => requireState().parent.on(type, handler),
-    };
-    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);
-            });
-            // Replay subscriptions registered before init. Capture each real disposer
-            // so a post-init unsubscribe (via the closure returned at subscribe time)
-            // actually removes the handler from the router instead of no-op'ing.
-            for (const entry of pendingIntentSubs) {
-                if (entry.unsubscribed)
-                    continue;
-                entry.off = router.onLocal(entry.name, entry.handler);
-            }
-            pendingIntentSubs.length = 0;
-        },
-        onDispose: async () => {
-            if (mountController)
-                await mountController.dispose();
-            childrenChannel.dispose();
-            state?.parent.dispose();
-            state?.kernel.dispose();
-        },
-    });
-}
-function buildShellFacade(deps) {
-    let disposed = false;
-    const shell = {
-        get parent() {
-            return deps.parent;
-        },
-        children: deps.childrenChannel,
-        kernel: deps.kernel,
-        windows: deps.windows,
-        get targetNodeId() {
-            return deps.targetNodeId?.();
-        },
-        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/application/windowing/child-init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"child-init.d.ts","sourceRoot":"","sources":["../../../src/application/windowing/child-init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAEvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAKzE,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,kBAAkB,CAAA;AAGzB,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,CAoGlF"}

package/dist/application/windowing/handshake.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handshake.d.ts","sourceRoot":"","sources":["../../../src/application/windowing/handshake.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAA;IAClC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC9E;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAEjD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAC3B,CAAA;AAED,qGAAqG;AACrG,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAsEpF"}

package/dist/application/windowing/lifecycle-controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycle-controller.d.ts","sourceRoot":"","sources":["../../../src/application/windowing/lifecycle-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAE7D,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAE/E,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/mount-controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mount-controller.d.ts","sourceRoot":"","sources":["../../../src/application/windowing/mount-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,2BAA2B,CAAA;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAA;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAWjE,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,YAAY,CAAA;IACrB,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,yBAAyB,CAAA;IAC1C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,SAAS,EAAE,mBAAmB,CAAA;CAC/B,CAAA;AAED,MAAM,WAAW,eAAe;IAC9B,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;IAC7F,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAiBD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CAqPpF"}

package/dist/application/windowing/mount-controller.js

@@ -1,277 +0,0 @@
-import { createMessagePortTransport } from '../../adapters/message-port.transport';
-import { runParentHandshake } from './handshake';
-import { createTokenRefresher } from './token-refresh';
-const DEFAULT_HANDSHAKE_TIMEOUT = 5_000;
-const DEFAULT_DELEGATION_TTL = 3_600;
-const DEFAULT_CLOSE_TIMEOUT = 3_000;
-const PARENT_SENDER_ID = '<parent>';
-/** No-op refresher for plain mounts (no token to refresh). */
-const NOOP_REFRESHER = {
-    start: () => { },
-    stop: () => { },
-    forceRefreshNow: () => Promise.resolve(),
-};
-export function createMountController(config) {
-    const { adapter, kernel, kernelUrl, mintIdentity, childrenChannel, windows, lifecycle } = config;
-    // The child iframe is always a DIFFERENT origin from this parent window, so a
-    // relative kernelUrl (e.g. the SPA's same-origin `/api/`) handed across the
-    // handshake would resolve against the iframe's OWN origin and POST to the
-    // wrong host. Absolutize it against the parent's location once so every child
-    // calls THIS origin's kernel. (The parent's own calls keep using the relative
-    // form via its kernel client / fetch.)
-    const childKernelUrl = new URL(kernelUrl, window.location.href).href;
-    const entries = new Map();
-    let seq = 0;
-    let disposed = false;
-    function nextWindowId(functionId) {
-        seq += 1;
-        const slug = functionId.replace(/[^a-z0-9]/gi, '').slice(-8) || 'fn';
-        return `win-${slug}-${seq}`;
-    }
-    async function mint(ttlSeconds) {
-        const credential = await kernel.mintDelegation();
-        return { credential, expiresAt: Date.now() + ttlSeconds * 1_000 };
-    }
-    function originOf(url) {
-        try {
-            return new URL(url, window.location.href).origin;
-        }
-        catch {
-            throw new Error(`Invalid mount url: ${url}`);
-        }
-    }
-    // Plain-iframe mount path — for hosted views that don't speak the shell
-    // protocol. No handshake, no transport, no delegation token, no refresher;
-    // the iframe just renders. `close()` skips the ack request (no channel) and
-    // falls straight to dispose.
-    async function mountPlain(params) {
-        const windowId = nextWindowId(params.functionId);
-        const { handle, dispose: disposeHandle } = adapter.mount({
-            functionId: params.functionId,
-            isolation: 'sandboxed',
-            capabilities: params.capabilities,
-            sandbox: params.sandbox,
-        });
-        if (!(handle.element instanceof HTMLIFrameElement)) {
-            disposeHandle();
-            throw new Error('Shell adapter did not produce an HTMLIFrameElement');
-        }
-        params.host.appendChild(handle.element);
-        handle.element.src = params.url;
-        windows.set(windowId, {
-            windowId,
-            functionId: params.functionId,
-            targetNodeId: params.targetNodeId,
-            isolation: 'sandboxed',
-            state: 'active',
-            delegationToken: null,
-            capabilities: params.capabilities,
-        });
-        lifecycle.register(windowId, 'active');
-        entries.set(windowId, {
-            handle,
-            dispose: disposeHandle,
-            refresher: NOOP_REFRESHER,
-            plain: true,
-        });
-        return {
-            windowId,
-            get window() {
-                return windows.get(windowId);
-            },
-            handle: { element: handle.element },
-            close: (opts) => controller.close(windowId, opts),
-        };
-    }
-    const controller = {
-        async mount(params) {
-            if (disposed)
-                throw new Error('MountController is disposed');
-            // Plain (no-handshake) path: hosted views that don't speak the shell
-            // protocol. Skip mint/handshake/transport/refresher; the iframe still
-            // renders and `close()` falls through to dispose.
-            if (params.handshake === 'none')
-                return mountPlain(params);
-            const ttlSeconds = params.delegationTtlSeconds ?? DEFAULT_DELEGATION_TTL;
-            const handshakeTimeout = params.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT;
-            const expectedOrigin = originOf(params.url);
-            const windowId = nextWindowId(params.functionId);
-            // Mint the token and create the iframe in parallel — the iframe
-            // doesn't need the credential until the handshake fires.
-            const [{ credential, expiresAt }, mounted] = await Promise.all([
-                mint(ttlSeconds),
-                Promise.resolve(adapter.mount({
-                    functionId: params.functionId,
-                    isolation: 'sandboxed',
-                    capabilities: params.capabilities,
-                    sandbox: params.sandbox,
-                })),
-            ]);
-            const { handle, dispose: disposeHandle } = mounted;
-            if (!(handle.element instanceof HTMLIFrameElement)) {
-                disposeHandle();
-                throw new Error('Shell adapter did not produce an HTMLIFrameElement');
-            }
-            params.host.appendChild(handle.element);
-            handle.element.src = params.url;
-            let handshakeResult;
-            try {
-                handshakeResult = await runParentHandshake({
-                    iframe: handle.element,
-                    expectedOrigin,
-                    windowId,
-                    delegationToken: credential,
-                    tokenExpiresAt: expiresAt,
-                    kernelUrl: childKernelUrl,
-                    functionId: params.functionId,
-                    targetNodeId: params.targetNodeId,
-                    mintIdentity,
-                    timeoutMs: handshakeTimeout,
-                });
-            }
-            catch (err) {
-                disposeHandle();
-                throw err;
-            }
-            const transport = createMessagePortTransport({
-                port: handshakeResult.port,
-                onClose: () => {
-                    if (!entries.has(windowId))
-                        return;
-                    lifecycle.markCrashed(windowId);
-                    void controller.close(windowId, { force: true }).catch(() => { });
-                },
-            });
-            childrenChannel.attach(windowId, transport);
-            windows.set(windowId, {
-                windowId,
-                functionId: params.functionId,
-                targetNodeId: params.targetNodeId,
-                isolation: 'sandboxed',
-                state: 'active',
-                delegationToken: credential,
-                capabilities: params.capabilities,
-            });
-            lifecycle.register(windowId, 'active');
-            // The live expiry advances on every refresh. The Window store only keeps
-            // the credential, so track expiry here — otherwise `token()` keeps
-            // returning the original expiry and `schedule()` collapses its lead time
-            // to 0, busy-looping `mint()` forever after the first refresh.
-            let currentExpiresAt = expiresAt;
-            const refresher = createTokenRefresher({
-                functionId: params.functionId,
-                token: () => {
-                    const stored = windows.get(windowId);
-                    return {
-                        credential: stored?.delegationToken ?? credential,
-                        expiresAt: currentExpiresAt,
-                        issuedAt: 0,
-                        scope: { functionId: params.functionId },
-                    };
-                },
-                setToken: (next) => {
-                    currentExpiresAt = next.expiresAt;
-                    const stored = windows.get(windowId);
-                    if (stored) {
-                        windows.set(windowId, { ...stored, delegationToken: next.credential });
-                    }
-                    childrenChannel.send(windowId, {
-                        type: 'ctrl',
-                        version: 1,
-                        action: 'tokenRefresh',
-                        data: { delegationToken: next.credential, tokenExpiresAt: next.expiresAt },
-                    });
-                },
-                mint: () => mint(ttlSeconds),
-                onFailure: () => {
-                    void controller.close(windowId, { force: false }).catch(() => { });
-                },
-            });
-            refresher.start();
-            entries.set(windowId, { handle, dispose: disposeHandle, refresher });
-            return {
-                windowId,
-                get window() {
-                    return windows.get(windowId);
-                },
-                handle: { element: handle.element },
-                close: (opts) => controller.close(windowId, opts),
-            };
-        },
-        async close(windowId, opts) {
-            const entry = entries.get(windowId);
-            if (!entry)
-                return { kind: 'noop' };
-            const timeoutMs = opts?.timeoutMs ?? DEFAULT_CLOSE_TIMEOUT;
-            // Plain mounts have no channel to ack a close; always force.
-            if (!opts?.force && !entry.plain) {
-                // Move the window into `closing` so the state machine accepts the
-                // subsequent `closeRefuse`/`forceClose` transition (both are only valid
-                // from `closing`).
-                lifecycle.apply(windowId, { kind: 'requestClose' });
-                const accepted = await requestCloseAck(childrenChannel, windowId, timeoutMs);
-                if (accepted.kind === 'refused') {
-                    lifecycle.apply(windowId, { kind: 'closeRefuse' });
-                    return { kind: 'refused', reason: accepted.reason };
-                }
-            }
-            lifecycle.apply(windowId, { kind: 'forceClose' });
-            entry.refresher.stop();
-            // Drop the entry before detaching: `detach` synchronously closes the
-            // transport, whose `onClose` re-enters `close()`. Removing the entry first
-            // makes that re-entrant call's `entries.has(windowId)` guard short-circuit,
-            // so `entry.dispose()` runs exactly once (adapters need not be idempotent).
-            entries.delete(windowId);
-            childrenChannel.detach(windowId);
-            windows.delete(windowId);
-            entry.dispose();
-            lifecycle.remove(windowId);
-            return { kind: 'closed' };
-        },
-        async dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            const ids = [...entries.keys()];
-            await Promise.all(ids.map((id) => controller.close(id, { force: true })));
-        },
-    };
-    return controller;
-}
-async function requestCloseAck(children, windowId, timeoutMs) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const off = children.on('intent', (from, message) => {
-            if (from !== windowId)
-                return;
-            if (message.envelope.name === 'closeAck') {
-                settled = true;
-                off();
-                clearTimeout(timer);
-                resolve({ kind: 'ack' });
-            }
-            else if (message.envelope.name === 'closeRefuse') {
-                settled = true;
-                off();
-                clearTimeout(timer);
-                const reason = message.envelope.payload.reason;
-                resolve({ kind: 'refused', reason });
-            }
-        });
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            off();
-            resolve({ kind: 'timeout' });
-        }, timeoutMs);
-        children.send(windowId, {
-            type: 'intent',
-            version: 1,
-            envelope: {
-                name: 'willClose',
-                payload: {},
-                sender: { windowId: PARENT_SENDER_ID },
-            },
-        });
-    });
-}

package/dist/application/windowing/protocol.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../src/application/windowing/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,iBAAiB,+BAA+B,CAAA;AAC7D,eAAO,MAAM,kBAAkB,gCAAgC,CAAA;AAE/D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,iBAAiB,CAAA;IACvC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAA;IACxC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAMzE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAM3E"}

package/dist/application/windowing/token-refresh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"token-refresh.d.ts","sourceRoot":"","sources":["../../../src/application/windowing/token-refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAIvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,eAAe,CAAA;IACrC,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAA;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAC7C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAC5B,CAAA;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,IAAI,IAAI,CAAA;IACb,IAAI,IAAI,IAAI,CAAA;IACZ,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACjC;AAID,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,kBAAkB,GAAG,cAAc,CAoD/E"}

package/dist/domain/identity/delegation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delegation.d.ts","sourceRoot":"","sources":["../../../src/domain/identity/delegation.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,QAAQ,CAAA;AAEnF,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,SAAU,CAAA;AAExC,wBAAgB,OAAO,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,SAAa,GAAG,UAAU,CAI5E;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,SAAa,GAAG,OAAO,CAE3E"}

package/dist/domain/identity/path.d.ts

@@ -1,11 +0,0 @@
-/**
- * Built-in kernel root identity, used as the default mint subject when no
- * explicit `mintIdentity` is configured.
- */
-export declare const SYSTEM_IDENTITY = "__system__";
-/**
- * Address a method on an identity or path: `@<id>::method` for a bare node id,
- * `<path>::method` for an absolute path (one starting with `/`).
- */
-export declare function identityMethod(identity: string, method: string): string;
-//# sourceMappingURL=path.d.ts.map

package/dist/domain/identity/path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/domain/identity/path.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,eAAe,eAAe,CAAA;AAE3C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGvE"}

package/dist/domain/identity/path.js

@@ -1,13 +0,0 @@
-/**
- * Built-in kernel root identity, used as the default mint subject when no
- * explicit `mintIdentity` is configured.
- */
-export const SYSTEM_IDENTITY = '__system__';
-/**
- * Address a method on an identity or path: `@<id>::method` for a bare node id,
- * `<path>::method` for an absolute path (one starting with `/`).
- */
-export function identityMethod(identity, method) {
-    const target = identity.startsWith('/') ? identity : `@${identity}`;
-    return `${target}::${method}`;
-}

package/dist/domain/identity/resolve-self.d.ts

@@ -1,21 +0,0 @@
-/** Kernel path that returns the AUTHENTICATED caller's own identity node. */
-export declare const WHOAMI_PATH = "/:kernel.astrale.ai:interface.Identity:whoami";
-/**
- * Resolve the mint SUBJECT — the identity node a delegation/credential should be
- * minted for. It MUST be the principal the kernel actually authenticates this
- * caller as, otherwise the minted token impersonates someone else.
- *
- * Why a kernel round-trip and not the local credential: a cookie-fronted SPA
- * holds an EMPTY credential string (the session token lives in an httpOnly
- * cookie it can't read), so the subject cannot be derived locally. We ask the
- * kernel via `whoami`; that request carries the cookie, so the router unseals it
- * and the kernel answers with the logged-in user's node. Without this the shell
- * defaulted every mint to `__system__`, so a View iframe mounted by a logged-in
- * user acted as the kernel ROOT instead of as that user.
- *
- * `fallback` (the configured `mintIdentity`, default `__system__`) is used when
- * whoami can't be resolved — a genuinely system/dev caller, or an unauthenticated
- * boot. The result is cached: the principal is stable for a session.
- */
-export declare function createSelfResolver(fallback?: string): (whoami: () => Promise<unknown>) => Promise<string>;
-//# sourceMappingURL=resolve-self.d.ts.map

package/dist/domain/identity/resolve-self.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-self.d.ts","sourceRoot":"","sources":["../../../src/domain/identity/resolve-self.ts"],"names":[],"mappings":"AAEA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,kDAAkD,CAAA;AAE1E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,GAAE,MAAwB,GACjC,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAarD"}

package/dist/domain/identity/resolve-self.js

@@ -1,36 +0,0 @@
-import { SYSTEM_IDENTITY } from './path';
-/** Kernel path that returns the AUTHENTICATED caller's own identity node. */
-export const WHOAMI_PATH = '/:kernel.astrale.ai:interface.Identity:whoami';
-/**
- * Resolve the mint SUBJECT — the identity node a delegation/credential should be
- * minted for. It MUST be the principal the kernel actually authenticates this
- * caller as, otherwise the minted token impersonates someone else.
- *
- * Why a kernel round-trip and not the local credential: a cookie-fronted SPA
- * holds an EMPTY credential string (the session token lives in an httpOnly
- * cookie it can't read), so the subject cannot be derived locally. We ask the
- * kernel via `whoami`; that request carries the cookie, so the router unseals it
- * and the kernel answers with the logged-in user's node. Without this the shell
- * defaulted every mint to `__system__`, so a View iframe mounted by a logged-in
- * user acted as the kernel ROOT instead of as that user.
- *
- * `fallback` (the configured `mintIdentity`, default `__system__`) is used when
- * whoami can't be resolved — a genuinely system/dev caller, or an unauthenticated
- * boot. The result is cached: the principal is stable for a session.
- */
-export function createSelfResolver(fallback = SYSTEM_IDENTITY) {
-    let cached;
-    return async (whoami) => {
-        if (cached !== undefined)
-            return cached;
-        try {
-            const me = (await whoami());
-            const id = me && typeof me.id === 'string' && me.id.length > 0 ? me.id : undefined;
-            cached = id ?? fallback;
-        }
-        catch {
-            cached = fallback;
-        }
-        return cached;
-    };
-}

package/dist/domain/intent/middleware/capabilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/intent/middleware/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,kBAAkB,GAAG,SAAS,CAAA;AAEjF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,cAAc,CAAA;CACtC,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;IAEjC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,mBAAmB,KAAK,IAAI,CAAA;IAE/D;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAE5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAC/B,CAAA;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,gBAAgB,CAkBnF"}

package/dist/domain/intent/middleware/logging.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../../src/domain/intent/middleware/logging.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;AAEvD,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,KAAK,CAAA;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAC5B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,aAAkB,GAAG,gBAAgB,CAQ9E"}