@the-open-engine/zeroshot 6.28.0 → 6.29.1

package/lib/hosted-session/authority.mjs

@@ -0,0 +1,57 @@
+import { ClusterConfigError } from '../cluster/index.mjs';
+const LOOPBACK_HOSTS = Object.freeze({
+    '127.0.0.1': true,
+    '::1': true,
+    '[::1]': true,
+});
+function parseCanonicalUrl(value, message, code) {
+    try {
+        if (/[\u0000-\u0020\u007f]/.test(value))
+            throw new TypeError('unsafe URL code point');
+        const url = new URL(value);
+        if (url.href !== value && url.origin !== value)
+            throw new TypeError('non-canonical URL');
+        return url;
+    }
+    catch {
+        throw new ClusterConfigError(message, code);
+    }
+}
+function hasOriginSuffix(url) {
+    return Boolean(url.username ||
+        url.password ||
+        url.pathname !== '/' ||
+        url.search ||
+        url.hash);
+}
+export function normalizedAuthority(value) {
+    const message = 'targetAuthority must be an HTTPS or literal-loopback HTTP origin';
+    const url = parseCanonicalUrl(value, message, 'INVALID_TARGET_AUTHORITY');
+    const loopbackHttp = url.protocol === 'http:' && LOOPBACK_HOSTS[url.hostname] === true;
+    if ((url.protocol !== 'https:' && !loopbackHttp) || hasOriginSuffix(url) ||
+        value !== url.origin) {
+        throw new ClusterConfigError(message, 'INVALID_TARGET_AUTHORITY');
+    }
+    return url.origin;
+}
+function accessAuthorityMatches(endpoint, target) {
+    const expectedProtocol = target.protocol === 'http:' ? 'ws:' : 'wss:';
+    return (endpoint.protocol === expectedProtocol &&
+        endpoint.host === target.host &&
+        !endpoint.username &&
+        !endpoint.password &&
+        !endpoint.search &&
+        !endpoint.hash);
+}
+export function validateHostedAccess(access, targetAuthority) {
+    const endpoint = parseCanonicalUrl(access.websocketUrl, 'access endpoint must be an absolute target WebSocket URL', 'INVALID_ACCESS_ENDPOINT');
+    if (endpoint.href !== access.websocketUrl ||
+        !accessAuthorityMatches(endpoint, new URL(targetAuthority))) {
+        throw new ClusterConfigError('access endpoint must remain on the exact target authority', 'INVALID_ACCESS_ENDPOINT');
+    }
+    if (access.protocol !== 'openengine.cluster/v1' ||
+        access.tokenType !== 'Bearer' ||
+        access.accessToken.length === 0) {
+        throw new ClusterConfigError('access grant does not match the hosted session contract', 'INVALID_ACCESS_GRANT');
+    }
+}

package/lib/hosted-session/coordinator.cjs

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HostedSessionCoordinator = void 0;
+exports.HostedSessionCoordinator = exports.HostedTransportUncertainError = exports.HostedAuthorizationError = exports.HostedAuthenticationError = void 0;
 const index_js_1 = require("../cluster/index.cjs");
+const authority_js_1 = require("./authority.cjs");
+const errors_js_1 = require("./errors.cjs");
+const reconnecting_watch_js_1 = require("./reconnecting-watch.cjs");
+var errors_js_2 = require("./errors.cjs");
+Object.defineProperty(exports, "HostedAuthenticationError", { enumerable: true, get: function () { return errors_js_2.HostedAuthenticationError; } });
+Object.defineProperty(exports, "HostedAuthorizationError", { enumerable: true, get: function () { return errors_js_2.HostedAuthorizationError; } });
+Object.defineProperty(exports, "HostedTransportUncertainError", { enumerable: true, get: function () { return errors_js_2.HostedTransportUncertainError; } });
 function combineSignals(signals) {
-    const defined = signals.filter((s) => s !== undefined);
+    const defined = signals.filter((signal) => signal !== undefined);
     if (defined.length === 0)
         return undefined;
     if (defined.length === 1)
@@ -11,15 +18,18 @@ function combineSignals(signals) {
     return AbortSignal.any(defined);
 }
 class HostedSessionCoordinator {
-    #getAccess;
-    #connectOptions;
+    #init;
+    #targetAuthority;
     #clock;
     #closeController = new AbortController();
+    #sessions = new Set();
     #referenceCapabilities;
     #closed = false;
     constructor(init) {
-        this.#getAccess = init.getAccess;
-        this.#connectOptions = init.connectOptions;
+        if (init.capsuleId.length === 0)
+            throw new index_js_1.ClusterConfigError('capsuleId must not be empty', 'INVALID_CAPSULE_ID');
+        this.#init = init;
+        this.#targetAuthority = (0, authority_js_1.normalizedAuthority)(init.targetAuthority);
         this.#clock = init.clock ?? Date;
     }
     async open(signal) {
@@ -31,66 +41,83 @@ class HostedSessionCoordinator {
     async replace(signal) {
         this.#requireNotClosed();
         const session = await this.#createSession(signal);
-        this.#verifyCapabilities(session.initializeResult.capabilities, session);
-        return session;
+        try {
+            if (this.#referenceCapabilities !== undefined) {
+                this.#verifyCapabilities(this.#referenceCapabilities, session.initializeResult.capabilities);
+            }
+            return session;
+        }
+        catch (error) {
+            await session.connection.close();
+            throw error;
+        }
+    }
+    async watch(options) {
+        const session = await this.open(options.signal);
+        try {
+            const subscription = await session.client.watch(options.params, options.signal === undefined ? {} : { signal: options.signal });
+            const hosted = new reconnecting_watch_js_1.ReconnectingHostedWatch((replacementSignal) => this.replace(replacementSignal), session, subscription, options.signal);
+            options.signal?.addEventListener('abort', () => {
+                void hosted.cancel().catch(() => undefined);
+            }, { once: true });
+            if (options.signal?.aborted) {
+                await hosted.cancel();
+                throw options.signal.reason ?? new DOMException('hosted watch aborted', 'AbortError');
+            }
+            return hosted;
+        }
+        catch (error) {
+            await session.connection.close();
+            throw error;
+        }
     }
     renewalDeadline(access, receivedAt) {
         const expiresAt = Date.parse(access.expiresAt);
-        if (Number.isNaN(expiresAt)) {
-            throw new index_js_1.ClusterConfigError(`invalid expiresAt: ${access.expiresAt}`, 'INVALID_EXPIRY');
+        if (!Number.isFinite(expiresAt) || expiresAt <= receivedAt) {
+            throw new index_js_1.ClusterConfigError('access expiry must be a future RFC 3339 timestamp', 'INVALID_ACCESS_EXPIRY');
         }
         const lifetime = expiresAt - receivedAt;
-        return Math.min(expiresAt - 30_000, receivedAt + 0.8 * lifetime);
+        const lead = Math.max(5_000, Math.min(60_000, Math.floor(lifetime * 0.1)));
+        return Math.max(receivedAt, expiresAt - lead);
     }
     async close() {
+        if (this.#closed)
+            return;
         this.#closed = true;
-        this.#closeController.abort();
+        this.#closeController.abort(new DOMException('coordinator closed', 'AbortError'));
+        const sessions = [...this.#sessions];
+        await Promise.all(sessions.map((session) => session.connection.close()));
+        this.#sessions.clear();
     }
     async #createSession(signal) {
         const combined = combineSignals([signal, this.#closeController.signal]);
-        const access = await this.#getAccess(combined);
-        const expiresAt = Date.parse(access.expiresAt);
-        if (Number.isNaN(expiresAt)) {
-            throw new index_js_1.ClusterConfigError(`invalid expiresAt: ${access.expiresAt}`, 'INVALID_EXPIRY');
-        }
-        if (expiresAt <= this.#clock.now()) {
-            throw new index_js_1.ClusterConfigError('access token is already expired', 'ACCESS_EXPIRED');
-        }
-        let endpoint;
+        const access = await this.#init.adapter.access(this.#init.capsuleId, combined);
+        (0, authority_js_1.validateHostedAccess)(access, this.#targetAuthority);
+        const receivedAt = this.#clock.now();
+        this.renewalDeadline(access, receivedAt);
         try {
-            endpoint = new URL(access.endpoint);
+            const session = await (0, index_js_1.connectInitialized)(access.websocketUrl, {
+                ...this.#init.connectOptions,
+                headers: { Authorization: `Bearer ${access.accessToken}` },
+                ...(combined === undefined ? {} : { signal: combined }),
+            });
+            this.#sessions.add(session);
+            void session.connection.closed.then(() => this.#sessions.delete(session));
+            return session;
         }
-        catch {
-            throw new index_js_1.ClusterConfigError('hosted access endpoint is invalid', 'INVALID_ENDPOINT');
+        catch (error) {
+            if (error instanceof index_js_1.ClusterUpgradeError && error.status === 401)
+                throw new errors_js_1.HostedAuthenticationError();
+            throw error;
         }
-        if (endpoint.protocol !== 'wss:') {
-            throw new index_js_1.ClusterConfigError('hosted access endpoint must use wss', 'INSECURE_ENDPOINT');
-        }
-        return (0, index_js_1.connectInitialized)(endpoint.href, {
-            ...this.#connectOptions,
-            headers: { Authorization: `Bearer ${access.token}` },
-            ...(combined !== undefined ? { signal: combined } : {}),
-        });
     }
-    #verifyCapabilities(incoming, session) {
-        if (!this.#referenceCapabilities)
-            return;
-        const ref = this.#referenceCapabilities;
-        const mismatches = [];
-        if (ref.graphProfiles) {
-            const incomingProfiles = new Set(incoming.graphProfiles ?? []);
-            for (const profile of ref.graphProfiles) {
-                if (!incomingProfiles.has(profile))
-                    mismatches.push(`missing graphProfile: ${profile}`);
-            }
-        }
-        if (ref.logs && !incoming.logs)
-            mismatches.push('missing capability: logs');
-        if (ref.agentAttach && !incoming.agentAttach)
-            mismatches.push('missing capability: agentAttach');
-        if (mismatches.length > 0) {
-            void session.connection.close();
-            throw new index_js_1.ClusterConfigError(`replacement capabilities incompatible: ${mismatches.join(', ')}`, 'INCOMPATIBLE_CAPABILITIES');
+    #verifyCapabilities(reference, incoming) {
+        const referenceProfiles = new Set(reference.graphProfiles ?? []);
+        const incomingProfiles = new Set(incoming.graphProfiles ?? []);
+        if ((reference.logs && !incoming.logs) ||
+            (reference.agentAttach && !incoming.agentAttach) ||
+            [...referenceProfiles].some((profile) => !incomingProfiles.has(profile))) {
+            throw new index_js_1.ClusterConfigError('replacement connection removed required server capabilities', 'CAPABILITY_REGRESSION');
         }
     }
     #requireNotClosed() {

package/lib/hosted-session/coordinator.d.cts

@@ -0,0 +1,11 @@
+import type { HostedAccess, HostedSessionInit, HostedWatch, HostedWatchOptions, InitializedSession } from './types.js';
+export { HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './errors.js';
+export declare class HostedSessionCoordinator {
+    #private;
+    constructor(init: HostedSessionInit);
+    open(signal?: AbortSignal): Promise<InitializedSession>;
+    replace(signal?: AbortSignal): Promise<InitializedSession>;
+    watch(options: HostedWatchOptions): Promise<HostedWatch>;
+    renewalDeadline(access: HostedAccess, receivedAt: number): number;
+    close(): Promise<void>;
+}

package/lib/hosted-session/coordinator.d.mts

@@ -0,0 +1,11 @@
+import type { HostedAccess, HostedSessionInit, HostedWatch, HostedWatchOptions, InitializedSession } from './types.js';
+export { HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './errors.js';
+export declare class HostedSessionCoordinator {
+    #private;
+    constructor(init: HostedSessionInit);
+    open(signal?: AbortSignal): Promise<InitializedSession>;
+    replace(signal?: AbortSignal): Promise<InitializedSession>;
+    watch(options: HostedWatchOptions): Promise<HostedWatch>;
+    renewalDeadline(access: HostedAccess, receivedAt: number): number;
+    close(): Promise<void>;
+}

package/lib/hosted-session/coordinator.d.ts

@@ -1,9 +1,11 @@
-import type { AccessResponse, HostedSessionInit, InitializedSession } from './types.js';
+import type { HostedAccess, HostedSessionInit, HostedWatch, HostedWatchOptions, InitializedSession } from './types.js';
+export { HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './errors.js';
 export declare class HostedSessionCoordinator {
     #private;
     constructor(init: HostedSessionInit);
     open(signal?: AbortSignal): Promise<InitializedSession>;
     replace(signal?: AbortSignal): Promise<InitializedSession>;
-    renewalDeadline(access: AccessResponse, receivedAt: number): number;
+    watch(options: HostedWatchOptions): Promise<HostedWatch>;
+    renewalDeadline(access: HostedAccess, receivedAt: number): number;
     close(): Promise<void>;
 }

package/lib/hosted-session/coordinator.mjs

@@ -1,6 +1,10 @@
-import { ClusterConfigError, connectInitialized } from '../cluster/index.mjs';
+import { ClusterConfigError, ClusterUpgradeError, connectInitialized, } from '../cluster/index.mjs';
+import { normalizedAuthority, validateHostedAccess } from './authority.mjs';
+import { HostedAuthenticationError } from './errors.mjs';
+import { ReconnectingHostedWatch } from './reconnecting-watch.mjs';
+export { HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './errors.mjs';
 function combineSignals(signals) {
-    const defined = signals.filter((s) => s !== undefined);
+    const defined = signals.filter((signal) => signal !== undefined);
     if (defined.length === 0)
         return undefined;
     if (defined.length === 1)
@@ -8,15 +12,18 @@ function combineSignals(signals) {
     return AbortSignal.any(defined);
 }
 export class HostedSessionCoordinator {
-    #getAccess;
-    #connectOptions;
+    #init;
+    #targetAuthority;
     #clock;
     #closeController = new AbortController();
+    #sessions = new Set();
     #referenceCapabilities;
     #closed = false;
     constructor(init) {
-        this.#getAccess = init.getAccess;
-        this.#connectOptions = init.connectOptions;
+        if (init.capsuleId.length === 0)
+            throw new ClusterConfigError('capsuleId must not be empty', 'INVALID_CAPSULE_ID');
+        this.#init = init;
+        this.#targetAuthority = normalizedAuthority(init.targetAuthority);
         this.#clock = init.clock ?? Date;
     }
     async open(signal) {
@@ -28,66 +35,83 @@ export class HostedSessionCoordinator {
     async replace(signal) {
         this.#requireNotClosed();
         const session = await this.#createSession(signal);
-        this.#verifyCapabilities(session.initializeResult.capabilities, session);
-        return session;
+        try {
+            if (this.#referenceCapabilities !== undefined) {
+                this.#verifyCapabilities(this.#referenceCapabilities, session.initializeResult.capabilities);
+            }
+            return session;
+        }
+        catch (error) {
+            await session.connection.close();
+            throw error;
+        }
+    }
+    async watch(options) {
+        const session = await this.open(options.signal);
+        try {
+            const subscription = await session.client.watch(options.params, options.signal === undefined ? {} : { signal: options.signal });
+            const hosted = new ReconnectingHostedWatch((replacementSignal) => this.replace(replacementSignal), session, subscription, options.signal);
+            options.signal?.addEventListener('abort', () => {
+                void hosted.cancel().catch(() => undefined);
+            }, { once: true });
+            if (options.signal?.aborted) {
+                await hosted.cancel();
+                throw options.signal.reason ?? new DOMException('hosted watch aborted', 'AbortError');
+            }
+            return hosted;
+        }
+        catch (error) {
+            await session.connection.close();
+            throw error;
+        }
     }
     renewalDeadline(access, receivedAt) {
         const expiresAt = Date.parse(access.expiresAt);
-        if (Number.isNaN(expiresAt)) {
-            throw new ClusterConfigError(`invalid expiresAt: ${access.expiresAt}`, 'INVALID_EXPIRY');
+        if (!Number.isFinite(expiresAt) || expiresAt <= receivedAt) {
+            throw new ClusterConfigError('access expiry must be a future RFC 3339 timestamp', 'INVALID_ACCESS_EXPIRY');
         }
         const lifetime = expiresAt - receivedAt;
-        return Math.min(expiresAt - 30_000, receivedAt + 0.8 * lifetime);
+        const lead = Math.max(5_000, Math.min(60_000, Math.floor(lifetime * 0.1)));
+        return Math.max(receivedAt, expiresAt - lead);
     }
     async close() {
+        if (this.#closed)
+            return;
         this.#closed = true;
-        this.#closeController.abort();
+        this.#closeController.abort(new DOMException('coordinator closed', 'AbortError'));
+        const sessions = [...this.#sessions];
+        await Promise.all(sessions.map((session) => session.connection.close()));
+        this.#sessions.clear();
     }
     async #createSession(signal) {
         const combined = combineSignals([signal, this.#closeController.signal]);
-        const access = await this.#getAccess(combined);
-        const expiresAt = Date.parse(access.expiresAt);
-        if (Number.isNaN(expiresAt)) {
-            throw new ClusterConfigError(`invalid expiresAt: ${access.expiresAt}`, 'INVALID_EXPIRY');
-        }
-        if (expiresAt <= this.#clock.now()) {
-            throw new ClusterConfigError('access token is already expired', 'ACCESS_EXPIRED');
-        }
-        let endpoint;
+        const access = await this.#init.adapter.access(this.#init.capsuleId, combined);
+        validateHostedAccess(access, this.#targetAuthority);
+        const receivedAt = this.#clock.now();
+        this.renewalDeadline(access, receivedAt);
         try {
-            endpoint = new URL(access.endpoint);
+            const session = await connectInitialized(access.websocketUrl, {
+                ...this.#init.connectOptions,
+                headers: { Authorization: `Bearer ${access.accessToken}` },
+                ...(combined === undefined ? {} : { signal: combined }),
+            });
+            this.#sessions.add(session);
+            void session.connection.closed.then(() => this.#sessions.delete(session));
+            return session;
         }
-        catch {
-            throw new ClusterConfigError('hosted access endpoint is invalid', 'INVALID_ENDPOINT');
+        catch (error) {
+            if (error instanceof ClusterUpgradeError && error.status === 401)
+                throw new HostedAuthenticationError();
+            throw error;
         }
-        if (endpoint.protocol !== 'wss:') {
-            throw new ClusterConfigError('hosted access endpoint must use wss', 'INSECURE_ENDPOINT');
-        }
-        return connectInitialized(endpoint.href, {
-            ...this.#connectOptions,
-            headers: { Authorization: `Bearer ${access.token}` },
-            ...(combined !== undefined ? { signal: combined } : {}),
-        });
     }
-    #verifyCapabilities(incoming, session) {
-        if (!this.#referenceCapabilities)
-            return;
-        const ref = this.#referenceCapabilities;
-        const mismatches = [];
-        if (ref.graphProfiles) {
-            const incomingProfiles = new Set(incoming.graphProfiles ?? []);
-            for (const profile of ref.graphProfiles) {
-                if (!incomingProfiles.has(profile))
-                    mismatches.push(`missing graphProfile: ${profile}`);
-            }
-        }
-        if (ref.logs && !incoming.logs)
-            mismatches.push('missing capability: logs');
-        if (ref.agentAttach && !incoming.agentAttach)
-            mismatches.push('missing capability: agentAttach');
-        if (mismatches.length > 0) {
-            void session.connection.close();
-            throw new ClusterConfigError(`replacement capabilities incompatible: ${mismatches.join(', ')}`, 'INCOMPATIBLE_CAPABILITIES');
+    #verifyCapabilities(reference, incoming) {
+        const referenceProfiles = new Set(reference.graphProfiles ?? []);
+        const incomingProfiles = new Set(incoming.graphProfiles ?? []);
+        if ((reference.logs && !incoming.logs) ||
+            (reference.agentAttach && !incoming.agentAttach) ||
+            [...referenceProfiles].some((profile) => !incomingProfiles.has(profile))) {
+            throw new ClusterConfigError('replacement connection removed required server capabilities', 'CAPABILITY_REGRESSION');
         }
     }
     #requireNotClosed() {

package/lib/hosted-session/errors.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostedTransportUncertainError = exports.HostedAuthorizationError = exports.HostedAuthenticationError = void 0;
+class HostedAuthenticationError extends Error {
+    constructor() {
+        super('Hosted target authentication failed');
+        this.name = 'HostedAuthenticationError';
+    }
+}
+exports.HostedAuthenticationError = HostedAuthenticationError;
+class HostedAuthorizationError extends Error {
+    constructor() {
+        super('Hosted target authorization was revoked');
+        this.name = 'HostedAuthorizationError';
+    }
+}
+exports.HostedAuthorizationError = HostedAuthorizationError;
+class HostedTransportUncertainError extends Error {
+    executionRetryAuthorized = false;
+    constructor() {
+        super('Hosted session transport closed with uncertain execution state');
+        this.name = 'HostedTransportUncertainError';
+    }
+}
+exports.HostedTransportUncertainError = HostedTransportUncertainError;

package/lib/hosted-session/errors.d.cts

@@ -0,0 +1,10 @@
+export declare class HostedAuthenticationError extends Error {
+    constructor();
+}
+export declare class HostedAuthorizationError extends Error {
+    constructor();
+}
+export declare class HostedTransportUncertainError extends Error {
+    readonly executionRetryAuthorized = false;
+    constructor();
+}

package/lib/hosted-session/errors.d.mts

@@ -0,0 +1,10 @@
+export declare class HostedAuthenticationError extends Error {
+    constructor();
+}
+export declare class HostedAuthorizationError extends Error {
+    constructor();
+}
+export declare class HostedTransportUncertainError extends Error {
+    readonly executionRetryAuthorized = false;
+    constructor();
+}

package/lib/hosted-session/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class HostedAuthenticationError extends Error {
+    constructor();
+}
+export declare class HostedAuthorizationError extends Error {
+    constructor();
+}
+export declare class HostedTransportUncertainError extends Error {
+    readonly executionRetryAuthorized = false;
+    constructor();
+}

package/lib/hosted-session/errors.mjs

@@ -0,0 +1,19 @@
+export class HostedAuthenticationError extends Error {
+    constructor() {
+        super('Hosted target authentication failed');
+        this.name = 'HostedAuthenticationError';
+    }
+}
+export class HostedAuthorizationError extends Error {
+    constructor() {
+        super('Hosted target authorization was revoked');
+        this.name = 'HostedAuthorizationError';
+    }
+}
+export class HostedTransportUncertainError extends Error {
+    executionRetryAuthorized = false;
+    constructor() {
+        super('Hosted session transport closed with uncertain execution state');
+        this.name = 'HostedTransportUncertainError';
+    }
+}

package/lib/hosted-session/index.cjs

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HostedSessionCoordinator = void 0;
+exports.HostedTransportUncertainError = exports.HostedAuthorizationError = exports.HostedAuthenticationError = exports.HostedSessionCoordinator = void 0;
 var coordinator_js_1 = require("./coordinator.cjs");
 Object.defineProperty(exports, "HostedSessionCoordinator", { enumerable: true, get: function () { return coordinator_js_1.HostedSessionCoordinator; } });
+Object.defineProperty(exports, "HostedAuthenticationError", { enumerable: true, get: function () { return coordinator_js_1.HostedAuthenticationError; } });
+Object.defineProperty(exports, "HostedAuthorizationError", { enumerable: true, get: function () { return coordinator_js_1.HostedAuthorizationError; } });
+Object.defineProperty(exports, "HostedTransportUncertainError", { enumerable: true, get: function () { return coordinator_js_1.HostedTransportUncertainError; } });

package/lib/hosted-session/index.d.cts

@@ -0,0 +1,2 @@
+export { HostedSessionCoordinator, HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './coordinator.js';
+export type { HostedAccess, HostedAccessAdapter, HostedSessionInit, HostedWatch, HostedWatchOptions, InitializedSession, } from './types.js';

package/lib/hosted-session/index.d.mts

@@ -0,0 +1,2 @@
+export { HostedSessionCoordinator, HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './coordinator.js';
+export type { HostedAccess, HostedAccessAdapter, HostedSessionInit, HostedWatch, HostedWatchOptions, InitializedSession, } from './types.js';

package/lib/hosted-session/index.d.ts

@@ -1,2 +1,2 @@
-export { HostedSessionCoordinator } from './coordinator.js';
-export type { AccessResponse, HostedSessionInit, InitializedSession } from './types.js';
+export { HostedSessionCoordinator, HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './coordinator.js';
+export type { HostedAccess, HostedAccessAdapter, HostedSessionInit, HostedWatch, HostedWatchOptions, InitializedSession, } from './types.js';

package/lib/hosted-session/index.mjs

@@ -1 +1 @@
-export { HostedSessionCoordinator } from './coordinator.mjs';
+export { HostedSessionCoordinator, HostedAuthenticationError, HostedAuthorizationError, HostedTransportUncertainError, } from './coordinator.mjs';