@astrale-os/kernel-client 0.6.0-beta.2 → 0.6.0-beta.21

package/dist/session/discovery/transport.d.ts

@@ -0,0 +1,6 @@
+import type { TransportPhase } from '../../errors/index.js';
+import type { SessionOperation } from '../context/index.js';
+type AcquisitionResource = 'publication' | 'bundle';
+/** Normalize only unknown failures from one injected acquisition capability. */
+export declare function runAcquisition<Result>(operation: SessionOperation, resource: AcquisitionResource, phase: Extract<TransportPhase, 'receive' | 'unknown'>, message: string, task: (signal: AbortSignal) => Result | PromiseLike<Result>): Promise<Result>;
+export {};

package/dist/session/discovery/transport.js

@@ -0,0 +1,13 @@
+import { ClientError, TransportError } from '../../errors/index.js';
+import { runSessionOperation } from '../context/index.js';
+/** Normalize only unknown failures from one injected acquisition capability. */
+export async function runAcquisition(operation, resource, phase, message, task) {
+    try {
+        return await runSessionOperation(operation, task);
+    }
+    catch (cause) {
+        if (cause instanceof ClientError)
+            throw cause;
+        throw TransportError.acquisition(message, { cause, phase, resource });
+    }
+}

package/dist/session/index.d.ts

@@ -1,7 +1,9 @@
 export type { SessionControlOptions, SessionPolicy } from './context/index.js';
-export type { ReadyInstallation as InstalledDomain } from '../schema/index.js';
+export { bindSession, type BoundClientSession, type BoundSessionControls, type BoundSessionSource, } from './bound.js';
 export type { SessionSnapshot } from './discovery/index.js';
-export type { Auth, BoundTarget, SessionAuth, SessionEnvelopeTransport, SessionRequestOptions, } from './routing/index.js';
-export { ClientSession, connect, dispatchBound, type ClientSessionOptions, type ConnectOptions, } from './session.js';
+export type { Auth, SessionAuth, SessionEnvelopeTransport, SessionRequestOptions, } from './routing/index.js';
+export { ClientSession, connect, type ClientSessionOptions, type ConnectOptions, } from './session.js';
+export type { CallableReference, InputOfReference, InstanceCallableReference, OutputOfReference, } from './reference.js';
+export { reference } from './reference.js';
 export type { ResolvedView, ViewCatalog } from './views/index.js';
-//# sourceMappingURL=index.d.ts.map
+export type { DomainBinding } from '../graph/domain/index.js';

package/dist/session/index.js

@@ -1,2 +1,3 @@
-export { ClientSession, connect, dispatchBound, } from './session.js';
-//# sourceMappingURL=index.js.map
+export { bindSession, } from './bound.js';
+export { ClientSession, connect, } from './session.js';
+export { reference } from './reference.js';

package/dist/session/reference.d.ts

@@ -0,0 +1,36 @@
+import type { Path as PathValue, PathLike } from '@astrale-os/kernel-core/path';
+import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, MethodInheritance, ResolvedFunction, ResolvedMethod } from '@astrale-os/kernel-dsl/v1';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { Binary, Input } from '../client/index.js';
+declare const REFERENCE_INPUT: unique symbol;
+declare const REFERENCE_OUTPUT: unique symbol;
+export interface CallableReference<InputValue extends Input = Input, Output = unknown> {
+    readonly origin: KeyType.Origin;
+    readonly revision: Revision;
+    readonly callable: KeyType.Callable;
+    readonly target: PathValue;
+    readonly outputMode: 'value' | 'stream' | 'binary';
+    readonly [REFERENCE_INPUT]?: InputValue;
+    readonly [REFERENCE_OUTPUT]?: Output;
+}
+export interface InstanceCallableReference<InputValue extends Input = Input, Output = unknown> {
+    (receiver: PathLike): CallableReference<InputValue, Output>;
+    readonly origin: KeyType.Origin;
+    readonly revision: Revision;
+    readonly callable: KeyType.Callable;
+    readonly outputMode: 'value' | 'stream' | 'binary';
+}
+export type InputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer InputValue, unknown> ? InputValue : never;
+export type OutputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer _Input, infer Output> ? Output : never;
+type ReferenceInput<Callable> = unknown extends CallableInputOf<Callable> ? Input : Extract<CallableInputOf<Callable>, Input>;
+type ReferenceOutput<Callable> = unknown extends CallableOutputOf<Callable> ? unknown : CallableResultOf<Callable, Binary>;
+type ExecutableMethodInheritance = Exclude<MethodInheritance, 'abstract'>;
+type ExecutableStaticMethod = ResolvedMethod<unknown, unknown, true, ExecutableMethodInheritance>;
+type ExecutableInstanceMethod = ResolvedMethod<unknown, unknown, false, ExecutableMethodInheritance>;
+/** Project one exact resolved Function or static Method into a typed Client reference. */
+export declare function reference<const Callable extends ResolvedFunction | ExecutableStaticMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): CallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>>;
+/** Project one exact resolved instance Method into a receiver-bound typed Client reference. */
+export declare function reference<const Callable extends ExecutableInstanceMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): InstanceCallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>>;
+export declare function admitReference(input: CallableReference): CallableReference;
+export {};

package/dist/session/reference.js

@@ -0,0 +1,74 @@
+import { Path } from '@astrale-os/kernel-core/path';
+import { callableAddress, Key, patterns, } from '@astrale-os/kernel-dsl/v1/addressing';
+export function reference(domain, callable) {
+    if ('owner' in callable && callable.inheritance === 'abstract')
+        invalid();
+    const common = Object.freeze({
+        origin: domain.origin,
+        revision: domain.revision,
+        callable: callable.key,
+        outputMode: callable.output.mode,
+    });
+    if ('owner' in callable && !callable.static) {
+        const bind = (receiver) => admitReference({
+            ...common,
+            target: Path.instanceMethod(Path.from(receiver), callable.name),
+        });
+        return Object.assign(bind, common);
+    }
+    const target = 'owner' in callable
+        ? Path.staticMethod(Path.project(callable.owner.ref), callable.name)
+        : Path.project(callable.ref);
+    return admitReference({ ...common, target });
+}
+export function admitReference(input) {
+    if (input === null || typeof input !== 'object')
+        invalid();
+    if (typeof input.origin !== 'string' ||
+        !patterns.origin.test(input.origin) ||
+        typeof input.revision !== 'string' ||
+        !patterns.revision.test(input.revision) ||
+        typeof input.callable !== 'string' ||
+        !Key.is(input.callable) ||
+        Key.origin(input.callable) !== input.origin ||
+        !['value', 'stream', 'binary'].includes(input.outputMode))
+        invalid();
+    const target = Path.from(input.target);
+    if (!matchesCallable(target, input.callable))
+        invalid();
+    return Object.freeze({
+        origin: input.origin,
+        revision: input.revision,
+        callable: input.callable,
+        target,
+        outputMode: input.outputMode,
+    });
+}
+function matchesCallable(target, callable) {
+    const coordinate = callableAddress(callable);
+    const { anchor, steps } = target.ast;
+    const last = steps.at(-1);
+    if (coordinate.kind === 'method') {
+        if (last?.kind !== 'method' || last.name !== coordinate.name)
+            return false;
+        if (last.dispatch === 'instance')
+            return true;
+        const owner = steps.at(-2);
+        return (anchor.kind === 'domain' &&
+            anchor.origin === Key.origin(callable) &&
+            steps.length === 2 &&
+            owner?.kind === 'projection' &&
+            owner.projection.kind === 'class' &&
+            owner.projection.name === coordinate.owner.name);
+    }
+    const projection = steps[0];
+    return (anchor.kind === 'domain' &&
+        anchor.origin === Key.origin(callable) &&
+        steps.length === 1 &&
+        projection?.kind === 'projection' &&
+        projection.projection.kind === 'function' &&
+        projection.projection.name === coordinate.name);
+}
+function invalid() {
+    throw new TypeError('Callable reference is invalid.');
+}

package/dist/session/routing/auth.d.ts

@@ -1,4 +1,4 @@
-import type { invocation } from '@astrale-os/kernel-protocol';
+import type * as invocation from '@astrale-os/kernel-protocol/invocation';
 import type { SessionOperation } from '../context/index.js';
 export interface Auth {
     readonly credential?: string;
@@ -16,4 +16,3 @@ export interface EffectiveAuth {
 }
 export declare function admitSessionAuth(input: SessionAuth | undefined): SessionAuth | undefined;
 export declare function resolveAuth(resolver: SessionAuth | undefined, call: invocation.Call, operation: SessionOperation): Promise<EffectiveAuth>;
-//# sourceMappingURL=auth.d.ts.map

package/dist/session/routing/auth.js

@@ -1,4 +1,4 @@
-import { invocation as protocol } from '@astrale-os/kernel-protocol';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { ClientError } from '../../errors/index.js';
 import { runSessionOperation } from '../context/index.js';
 export function admitSessionAuth(input) {
@@ -37,4 +37,3 @@ export async function resolveAuth(resolver, call, operation) {
         : protocol.acceptDelegate(input.delegate);
     return Object.freeze({ credential, delegate });
 }
-//# sourceMappingURL=auth.js.map

package/dist/session/routing/cache.d.ts

@@ -1,6 +1,6 @@
 import type { invocation } from '@astrale-os/kernel-protocol';
 import type { EffectiveAuth } from './auth.js';
-import type { BoundTarget } from './bound.js';
+import type { SchemaExpectation } from './expectation.js';
 export interface LearnedRoute {
     readonly route: invocation.Route;
     readonly credential?: string;
@@ -12,10 +12,9 @@ export declare class RouteCache {
     private readonly maximumSize;
     private readonly entries;
     constructor(maximumAgeMs: number, maximumSize?: number);
-    key(source: string, call: invocation.Call, auth: EffectiveAuth, expected?: BoundTarget): Promise<string>;
+    key(source: string, call: invocation.Call, auth: EffectiveAuth, expected?: SchemaExpectation): Promise<string>;
     get(key: string, now?: number): LearnedRoute | undefined;
     learn(key: string, route: invocation.Route, credential: string | undefined, now?: number): LearnedRoute;
     delete(key: string): void;
     clear(): void;
 }
-//# sourceMappingURL=cache.d.ts.map

package/dist/session/routing/cache.js

@@ -16,18 +16,7 @@ export class RouteCache {
             call.target,
             credential,
             delegate,
-            expected === undefined
-                ? null
-                : [
-                    expected.schema,
-                    expected.publication === undefined
-                        ? null
-                        : [
-                            expected.publication.origin,
-                            expected.publication.revision,
-                            expected.publication.etag,
-                        ],
-                ],
+            expected === undefined ? null : [expected.origin, expected.revision],
         ]);
     }
     get(key, now = Date.now()) {
@@ -124,4 +113,3 @@ function decodeBase64(input) {
     }
     throw new TypeError('Session route caching requires base64 decoding support.');
 }
-//# sourceMappingURL=cache.js.map

package/dist/session/routing/dispatch.d.ts

@@ -1,12 +1,10 @@
-import type { IssuerId } from '@astrale-os/kernel-core/auth';
-import type { Result } from '@astrale-os/kernel-ports/functions';
-import type { Call } from '../../client/index.js';
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Call, Result } from '../../client/index.js';
 import type { SessionOperation, SessionPolicy } from '../context/index.js';
-import type { SessionDiscovery } from '../discovery/index.js';
 import type { SessionAuth } from './auth.js';
-import type { BoundTarget } from './bound.js';
 import type { RouteCache } from './cache.js';
 import type { ClientPoolCapability } from './envelope.js';
+import type { SchemaExpectation } from './expectation.js';
 import type { SessionEnvelopeTransport, SessionRequestOptions } from './request.js';
 export interface SessionDispatcherOptions {
     readonly kernel: IssuerId;
@@ -17,20 +15,17 @@ export interface SessionDispatcherOptions {
     readonly cache: RouteCache;
     readonly policy: Readonly<SessionPolicy>;
     readonly envelopeTransport: SessionEnvelopeTransport;
-    readonly discovery: SessionDiscovery;
     readonly requireOpen: () => void;
 }
 export declare class SessionDispatcher {
     private readonly state;
     constructor(state: SessionDispatcherOptions);
-    dispatch(input: Call, options: SessionRequestOptions, operation: SessionOperation, expected?: BoundTarget): Promise<Result>;
+    dispatch(input: Call, options: SessionRequestOptions, operation: SessionOperation, expected?: SchemaExpectation): Promise<Result>;
     private dispatchSource;
     private followSource;
     private dispatchDestinationWithRecovery;
     private dispatchDestination;
-    private sourceKernel;
 }
 export declare function requireResultKind<Kind extends 'value' | 'stream' | 'binary'>(expected: Kind, result: Result): Extract<Result, {
     kind: Kind;
 }>;
-//# sourceMappingURL=dispatch.d.ts.map

package/dist/session/routing/dispatch.js

@@ -1,4 +1,4 @@
-import { invocation as invocationProtocol, publication as publications, } from '@astrale-os/kernel-protocol';
+import * as invocationProtocol from '@astrale-os/kernel-protocol/invocation';
 import { acceptCall, dispatchTrace, isAdmittedMissError, isAdmittedStaleRouteError, } from '../../client/index.js';
 import { ClientError, ResponseError } from '../../errors/index.js';
 import { runSessionOperation, sessionTransportOptions, allowEndpoint } from '../context/index.js';
@@ -15,8 +15,8 @@ export class SessionDispatcher {
         // Authority is resolved before warm lookup so changed credentials or delegation cannot reuse a
         // carrier minted for a different caller partition.
         const auth = await resolveAuth(this.state.auth, call, operation);
-        const source = await this.sourceKernel(operation);
-        const cacheKey = await this.state.cache.key(source.issuer, call, auth, expected);
+        const source = this.state.kernel;
+        const cacheKey = await this.state.cache.key(source, call, auth, expected);
         const dispatch = Object.freeze({
             call,
             auth,
@@ -39,14 +39,14 @@ export class SessionDispatcher {
             ...sessionTransportOptions(operation, options.idempotencyKey),
             ...(state.auth.delegate === undefined ? {} : { delegate: state.auth.delegate }),
             ...(routing === undefined ? {} : { routing }),
-            ...(state.expected === undefined ? {} : { schema: state.expected.schema }),
+            ...(state.expected === undefined ? {} : { schema: { revision: state.expected.revision } }),
         }));
     }
     async followSource(result, state, options, operation) {
         if (result.kind !== 'redirect')
             return result;
         const redirect = result.redirect;
-        if (redirect.route.via.issuer !== state.source.issuer) {
+        if (redirect.route.via.issuer !== state.source) {
             throw new ClientError('Redirect issuer differs from the session-pinned source Kernel identity.');
         }
         requireExpectedPublication(redirect.route, state.expected);
@@ -55,7 +55,7 @@ export class SessionDispatcher {
     }
     async dispatchDestinationWithRecovery(learned, state, options, operation, trace) {
         try {
-            return await this.dispatchDestination(learned, state.call, options, operation, state.expected, trace);
+            return await this.dispatchDestination(learned, state.call, options, operation, state.source, state.expected, trace);
         }
         catch (cause) {
             const stale = isAdmittedStaleRouteError(cause);
@@ -79,8 +79,8 @@ export class SessionDispatcher {
             return this.followSource(refreshed, state, options, operation);
         }
     }
-    async dispatchDestination(learned, call, options, operation, expected, trace) {
-        if (learned.route.via.issuer !== (await this.sourceKernel(operation)).issuer) {
+    async dispatchDestination(learned, call, options, operation, source, expected, trace) {
+        if (learned.route.via.issuer !== source) {
             throw new ClientError('Learned route issuer differs from the session-pinned source Kernel.');
         }
         requireExpectedPublication(learned.route, expected);
@@ -97,13 +97,6 @@ export class SessionDispatcher {
         }
         return result;
     }
-    async sourceKernel(operation) {
-        const snapshot = await this.state.discovery.snapshot(operation);
-        if (snapshot.kernel !== this.state.kernel) {
-            throw new ClientError('Session discovery returned another Kernel identity.');
-        }
-        return Object.freeze({ issuer: snapshot.publication.identity.issuer });
-    }
 }
 function isRouteCompatibilityConflict(input) {
     if (!(input instanceof ResponseError))
@@ -114,18 +107,15 @@ function isRouteCompatibilityConflict(input) {
         ...(input.data === undefined ? {} : { data: input.data }),
     });
     return (failure?.data.code === invocationProtocol.SCHEMA_UPGRADE_REQUIRED ||
+        failure?.data.code === invocationProtocol.SCHEMA_REVISION_MISMATCH ||
         failure?.data.code === invocationProtocol.SERVICE_TRUST_REQUIRED);
 }
 function requireExpectedPublication(route, expected) {
     if (expected === undefined)
         return;
-    if (expected.publication === undefined) {
-        throw new ClientError('A local bound installation cannot resolve to a remote route.');
-    }
     const actual = route.via.publication;
-    const relation = publications.compareReferences(actual, expected.publication);
-    if (relation !== 'exact' && relation !== 'same-schema') {
-        throw new ClientError('Resolved route does not match the bound installed Publication.');
+    if (actual.origin !== expected.origin || actual.revision !== expected.revision) {
+        throw new ClientError('Resolved route does not match the expected Schema revision.');
     }
 }
 export function requireResultKind(expected, result) {
@@ -133,9 +123,11 @@ export function requireResultKind(expected, result) {
         return result;
     if (result.kind === 'stream')
         void result.stream.cancel(`Expected ${expected} result.`);
+    if (result.kind === 'binary' && !(result.value.body instanceof Uint8Array)) {
+        void result.value.body[Symbol.asyncIterator]().return?.();
+    }
     throw new ClientError(`Function returned ${result.kind}; ${expected} was required.`);
 }
 function authenticated(client, credential) {
     return credential === undefined ? client : client.as(credential);
 }
-//# sourceMappingURL=dispatch.js.map

package/dist/session/routing/envelope.d.ts

@@ -11,4 +11,3 @@ export interface EnvelopeSelection {
     readonly destination: ClientTarget;
 }
 export declare function selectEnvelope(endpoints: publication.InvocationEndpoints, preference: SessionEnvelopeTransport, websocketAvailable: boolean, pool: ClientPoolCapability, policy: Readonly<SessionPolicy>): EnvelopeSelection;
-//# sourceMappingURL=envelope.d.ts.map

package/dist/session/routing/envelope.js

@@ -33,4 +33,3 @@ export function selectEnvelope(endpoints, preference, websocketAvailable, pool,
     }
     return Object.freeze({ client, destination });
 }
-//# sourceMappingURL=envelope.js.map

package/dist/session/routing/expectation.d.ts

@@ -0,0 +1,6 @@
+import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
+/** Private static-consumer expectation carried only by ClientSession.invoke. */
+export interface SchemaExpectation {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+}

package/dist/session/routing/expectation.js

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

package/dist/session/routing/index.d.ts

@@ -1,7 +1,6 @@
 export { admitSessionAuth, resolveAuth, type Auth, type EffectiveAuth, type SessionAuth, } from './auth.js';
-export type { BoundTarget } from './bound.js';
+export type { SchemaExpectation } from './expectation.js';
 export { RouteCache, type LearnedRoute } from './cache.js';
 export { requireResultKind, SessionDispatcher, type SessionDispatcherOptions } from './dispatch.js';
 export { type ClientPoolCapability, type EnvelopeSelection } from './envelope.js';
 export { admitEnvelopeTransport, admitRequestOptions, type SessionEnvelopeTransport, type SessionRequestOptions, } from './request.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/session/routing/index.js

@@ -3,4 +3,3 @@ export { RouteCache } from './cache.js';
 export { requireResultKind, SessionDispatcher } from './dispatch.js';
 export {} from './envelope.js';
 export { admitEnvelopeTransport, admitRequestOptions, } from './request.js';
-//# sourceMappingURL=index.js.map

package/dist/session/routing/request.d.ts

@@ -1,4 +1,4 @@
-import type { invocation } from '@astrale-os/kernel-protocol';
+import type * as invocation from '@astrale-os/kernel-protocol/invocation';
 import type { SessionControlOptions } from '../context/index.js';
 export type SessionEnvelopeTransport = 'auto' | 'http' | 'websocket';
 export interface SessionRequestOptions extends SessionControlOptions {
@@ -6,4 +6,3 @@ export interface SessionRequestOptions extends SessionControlOptions {
 }
 export declare function admitRequestOptions(input?: SessionRequestOptions): Readonly<SessionRequestOptions>;
 export declare function admitEnvelopeTransport(input: SessionEnvelopeTransport): SessionEnvelopeTransport;
-//# sourceMappingURL=request.d.ts.map

package/dist/session/routing/request.js

@@ -1,4 +1,4 @@
-import { invocation as invocationProtocol } from '@astrale-os/kernel-protocol';
+import * as invocationProtocol from '@astrale-os/kernel-protocol/invocation';
 import { admitControlOptions } from '../context/index.js';
 export function admitRequestOptions(input = {}) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
@@ -23,4 +23,3 @@ export function admitEnvelopeTransport(input) {
     }
     return input;
 }
-//# sourceMappingURL=request.js.map

package/dist/session/session.d.ts

@@ -1,16 +1,17 @@
-import type { IssuerId } from '@astrale-os/kernel-core/auth';
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { PathLike } from '@astrale-os/kernel-core/path';
-import type { Key } from '@astrale-os/kernel-dsl/v1';
-import type { Input, Result } from '@astrale-os/kernel-ports/functions';
-import type { Call } from '../client/index.js';
+import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
+import type { Call, Input, Result } from '../client/index.js';
+import type { DomainBinding, GraphApi } from '../graph/index.js';
 import type { ClientFactory, ClientPool as ClientPoolType } from '../pool/index.js';
-import type { ReadyInstallation, SchemaApi } from '../schema/index.js';
+import type { SchemaApi } from '../schema/index.js';
 import type { ClientWarning } from '../transport/auto/index.js';
 import type { Fetch } from '../transport/http/index.js';
 import type { WebSocketConstructor } from '../transport/websocket/index.js';
 import type { SessionControlOptions, SessionPolicy } from './context/index.js';
 import type { SessionSnapshot } from './discovery/index.js';
-import type { SessionAuth, BoundTarget, SessionEnvelopeTransport, SessionRequestOptions } from './routing/index.js';
+import type { CallableReference, InputOfReference, OutputOfReference } from './reference.js';
+import type { SessionAuth, SessionEnvelopeTransport, SessionRequestOptions } from './routing/index.js';
 import type { ViewCatalog } from './views/index.js';
 export interface ClientSessionOptions {
     /** Exact canonical source Kernel identity; its invocation and discovery endpoints are derived. */
@@ -28,15 +29,15 @@ export interface ClientSessionOptions {
     readonly maximumResponseBytes?: number;
     readonly timeoutMs?: number;
 }
-export type ConnectOptions = Omit<ClientSessionOptions, 'policy'> & {
+export type ConnectOptions = Omit<ClientSessionOptions, 'kernel' | 'policy'> & {
+    readonly url: string;
     readonly policy?: SessionPolicy;
 };
-/** Package-private exact-Publication dispatch used by Domain bindings. */
-export declare function dispatchBound(session: ClientSession, call: Call, expected: BoundTarget, options?: SessionRequestOptions): Promise<Result>;
 /** Caller-owned discovery and redirect-following conversation with one exact source Kernel. */
 export declare class ClientSession {
     readonly kernel: IssuerId;
     readonly schema: SchemaApi;
+    readonly graph: GraphApi;
     private readonly ownedPool?;
     private readonly discovery;
     private readonly dispatcher;
@@ -46,17 +47,19 @@ export declare class ClientSession {
     private readonly admitTargetViews;
     private closed;
     constructor(options: ClientSessionOptions);
+    /** Bind one admitted DSL Domain to authenticated graph projection and Method dispatch. */
+    bind<const DomainValue extends Domain>(domain: DomainValue): DomainBinding<DomainValue>;
     snapshot(options?: SessionControlOptions): Promise<SessionSnapshot>;
     viewsFor(target: PathLike, options?: SessionControlOptions): Promise<ViewCatalog>;
-    installed(origin: Key.Origin, options?: SessionControlOptions): Promise<ReadyInstallation>;
     dispatch(call: Call, options?: SessionRequestOptions): Promise<Result>;
     call(call: Call, options?: SessionRequestOptions): Promise<Input>;
-    stream(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-ports/functions").Stream>;
-    binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-ports/functions").Binary>;
+    invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
+    stream(call: Call, options?: SessionRequestOptions): Promise<import("../client/result.js").Stream>;
+    binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-core/callable").BinaryOutput>;
     close(): void;
     private requireOpen;
+    private invokeDomainMethod;
     private operation;
 }
 /** Open one caller-owned conversation with a Kernel using secure defaults. */
 export declare function connect(options: ConnectOptions): ClientSession;
-//# sourceMappingURL=session.d.ts.map